Cisco-IOS-XR-mpls-ldp-mldp-oper

This module contains a collection of YANG definitions for Cisco IOS-XR mpls-ldp-mldp package operational data. This module cont...

  • Version: 2020-10-18

    Cisco-IOS-XR-mpls-ldp-mldp-oper@2020-10-18


    
      module Cisco-IOS-XR-mpls-ldp-mldp-oper {
    
        yang-version 1;
    
        namespace
          "http://cisco.com/ns/yang/Cisco-IOS-XR-mpls-ldp-mldp-oper";
    
        prefix mpls-ldp-mldp-oper;
    
        import ietf-inet-types {
          prefix inet;
        }
        import Cisco-IOS-XR-types {
          prefix xr;
        }
        import cisco-semver {
          prefix semver;
        }
    
        include Cisco-IOS-XR-mpls-ldp-mldp-oper-sub1 {
          revision-date "2020-10-18";
        }
    
        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 mpls-ldp-mldp package operational data.
    
    This module contains definitions
    for the following management objects:
      mpls-mldp: MPLS MLDP operational data
    
    Copyright (c) 2013-2020 by Cisco Systems, Inc.
    All rights reserved.";
    
        revision "2020-10-18" {
          description
            "Backward compatible removal in telemetry event Cisco-IOS-XR-types, event-telemetry was removed.";
        }
    
        revision "2019-04-05" {
          description
            "Establish semantic version baseline.";
        }
    
        revision "2018-08-30" {
          description
            "Operational Yang model for mLDP.";
        }
    
        revision "2015-11-09" {
          description "IOS XR 6.0 revision.";
        }
    
        semver:module-version "1.1.0";
        semver:module-version "1.1.0";
    
        typedef Lsp {
          type enumeration {
            enum "invalid" {
              value 0;
              description "Invalid LSP Type";
            }
            enum "any" {
              value 1;
              description "Any LSP Type";
            }
            enum "p2mp" {
              value 2;
              description "P2MP LSP Type";
            }
            enum "mp2mp-upstream" {
              value 3;
              description
                "MP2MP Upstream LSP Type";
            }
            enum "mp2mp-downstream" {
              value 4;
              description
                "MP2MP Downstream LSP Type";
            }
            enum "mp2mp" {
              value 5;
              description "MP2MP LSP Type";
            }
          }
          description "Lsp";
        }
    
        typedef Opaque {
          type enumeration {
            enum "static-id" {
              value 0;
              description
                "Static ID Opaque Type";
            }
            enum "global-id" {
              value 1;
              description
                "Global ID Opaque Type";
            }
            enum "vpn-id" {
              value 2;
              description "VPN ID Opaque Type";
            }
            enum "ipv4" {
              value 3;
              description "IPv4 Opaque Type";
            }
            enum "ipv6" {
              value 4;
              description "IPv6 Opaque Type";
            }
            enum "ipv4-bidir" {
              value 5;
              description
                "IPv4 Bidir Opaque Type";
            }
            enum "ipv6-bidir" {
              value 6;
              description
                "IPv6 Bidir Opaque Type";
            }
            enum "recursive" {
              value 7;
              description
                "Recursive Opaque Type";
            }
            enum "recursive-route-distinguisher" {
              value 8;
              description
                "Recursive Route Distinguisher Opaque Type";
            }
            enum "vpnv4" {
              value 250;
              description "VPNv4 Opaque Type";
            }
            enum "vpnv6" {
              value 251;
              description "VPNv6 Opaque Type";
            }
          }
          description "Opaque";
        }
    
        container mpls-mldp {
          config false;
          description
            "MPLS MLDP operational data";
          container active {
            description
              "Active MPLS MLDP operational data";
            container status {
              description "MLDP Status";
              leaf mldp-active {
                type boolean;
                description
                  "MLDP has been activated";
              }
    
              leaf mldp-running {
                type boolean;
                description "MLDP is running";
              }
    
              leaf mldp-ready {
                type boolean;
                description "MLDP is ready";
              }
    
              leaf mldp-rib-connection-status {
                type boolean;
                description
                  "MLDP RIB connection status";
              }
    
              leaf mldp-rib-connection-open {
                type boolean;
                description
                  "MLDP RIB connection open";
              }
    
              leaf log-internal {
                type boolean;
                description
                  "Logging internal is enabled";
              }
    
              leaf log-notifications {
                type boolean;
                description
                  "Logging notifications is enabled";
              }
    
              leaf label-release-delay {
                type uint32;
                units "millisecond";
                description
                  "Label release delay in milli-seconds";
              }
    
              leaf lsm-id-delay {
                type uint32;
                units "millisecond";
                description
                  "LSM ID scan delay in milli-seconds";
              }
            }  // container status
    
            container mfi-entries {
              description "MLDP MFI Table";
              list mfi-entry {
                key "mpls-label";
                description
                  "MLDP MFI Information";
                leaf mpls-label {
                  type uint32;
                  description "MPLS Label";
                }
    
                leaf mpls-local-label {
                  type uint32;
                  description "Local Label";
                }
    
                leaf lsm-id {
                  type uint32;
                  description "LSM ID";
                }
    
                leaf head-lsm-id {
                  type uint32;
                  description "Head LSM ID";
                }
    
                leaf flags {
                  type uint32;
                  description "Flags";
                }
    
                leaf rpf-id {
                  type uint32;
                  description "RPF Identifier";
                }
    
                leaf interface-name {
                  type string {
                    length "0..65";
                  }
                  description
                    "LSP Virtual interface name";
                }
    
                list forwarding-path {
                  description "Path List";
                  leaf mpls-label {
                    type uint32;
                    description "Remote Label";
                  }
    
                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description "Next hop";
                  }
    
                  leaf interface-name {
                    type string {
                      length "0..65";
                    }
                    description "Interface name";
                  }
    
                  leaf out-info-flags {
                    type uint32;
                    description "Outinfo flags";
                  }
    
                  leaf role {
                    type uint32;
                    description "Role";
                  }
                }  // list forwarding-path
              }  // list mfi-entry
            }  // container mfi-entries
    
            container lsp-bindings {
              description
                "MLDP LSP Bindings Table";
              list lsp-binding {
                key "lsm-id";
                description
                  "MLDP LSP Binding Information";
                leaf lsm-id {
                  type uint32;
                  description "LSM ID";
                }
    
                leaf binding-id {
                  type uint32;
                  description
                    "ID used for this binding";
                }
    
                leaf num-paths {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type uint32;
                  description
                    "Number of paths in this LSP binding";
                }
    
                list opaque {
                  description "FEC Opaque List";
                  leaf tree-type {
                    type uint32;
                    description "Tree Type";
                  }
    
                  leaf lsmid {
                    type uint32;
                    description
                      "LSM ID of the paths in this LSP binding";
                  }
    
                  leaf root-address {
                    type inet:ipv4-address;
                    description "Root address";
                  }
    
                  leaf opaque-decoded-string {
                    type string {
                      length "0..255";
                    }
                    description
                      "Opaque value decoded string";
                  }
                }  // list opaque
    
                list binding-path {
                  description "Path List";
                  leaf lsmid {
                    type uint32;
                    description
                      "LSM ID of the paths in this LSP binding";
                  }
    
                  leaf acel-type {
                    type boolean;
                    description
                      "Binding is Accepting Element";
                  }
    
                  leaf branch-type {
                    type boolean;
                    description
                      "Binding is a branch";
                  }
    
                  leaf acel-active {
                    type boolean;
                    description
                      "This ACEL is active";
                  }
    
                  leaf branch-owner-type {
                    type uint32;
                    description
                      "Which type of branch";
                  }
    
                  leaf local-label {
                    type uint32;
                    description
                      "Local label allocated for this binding";
                  }
    
                  leaf remote-label {
                    type uint32;
                    description
                      "Remote label assigned to this binding";
                  }
    
                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next-hop address";
                  }
    
                  leaf rpf-id {
                    type uint32;
                    description "RPF Identifier";
                  }
    
                  leaf interface-name {
                    type string {
                      length "0..65";
                    }
                    description "Interface name";
                  }
                }  // list binding-path
              }  // list lsp-binding
            }  // container lsp-bindings
    
            container lsm-ids {
              description "MLDP LSM-ID";
              list lsm-id {
                key "lsm-id";
                description
                  "MLDP LSMID Information";
                leaf lsm-id {
                  type uint32;
                  description "LSM ID";
                }
    
                leaf lsm-id-xr {
                  type uint32;
                  description "LSM ID";
                }
    
                leaf vrf-name {
                  type string {
                    length "0..256";
                  }
                  description "VRF name";
                }
    
                leaf up-time {
                  type uint32;
                  units "millisecond";
                  description
                    "Uptime in milli-seconds";
                }
    
                leaf tree-type {
                  type uint32;
                  description "Tree Type";
                }
    
                leaf root-address-xr {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type inet:ipv4-address;
                  description "Root address";
                }
    
                leaf we-are-root {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type boolean;
                  description "We are the root";
                }
    
                leaf fec-opaque-length {
                  type uint32;
                  description
                    "FEC opaque length";
                }
    
                leaf opaque-decoded-string {
                  type string {
                    length "0..255";
                  }
                  description
                    "Opaque value decoded string";
                }
    
                leaf fec-value-length {
                  type uint32;
                  description "FEC Value length";
                }
    
                leaf root-node-redundency-lsm-id {
                  type uint32;
                  description "RNR LSM-ID";
                }
    
                leaf root-node-redundency-active {
                  type boolean;
                  description "RNR Active";
                }
    
                leaf root-node-redundency-is-primary {
                  type boolean;
                  description
                    "RNR Primary is this entry";
                }
    
                leaf root-node-redundency-lsm-id-primary {
                  type uint32;
                  description
                    "RNR Primary LSM ID";
                }
    
                leaf root-node-redundency-root-address {
                  type inet:ipv4-address;
                  description
                    "RNR Root node address";
                }
    
                leaf root-node-redundency-candidate-string {
                  type string {
                    length "0..80";
                  }
                  description
                    "RNR candidate list";
                }
    
                leaf is-ldp-branch {
                  type boolean;
                  description "LDP Branch";
                }
    
                leaf is-local-branch {
                  type boolean;
                  description "Local Branch";
                }
    
                leaf is-local-interface {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type boolean;
                  description "Local Interface";
                }
    
                leaf role-egress {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type boolean;
                  description "Role Egress";
                }
    
                leaf forwarding-peek {
                  type boolean;
                  description "Peek is enabled";
                }
    
                leaf make-before-break-enabled {
                  type boolean;
                  description
                    "MBB feature is enabled";
                }
    
                leaf mo-frr-enabled {
                  type boolean;
                  description
                    "MoFRR feature is enabled";
                }
    
                leaf recursive-fec-enabled {
                  type boolean;
                  description
                    "Recursive FEC is enabled";
                }
    
                leaf trace-enabled {
                  type boolean;
                  description
                    "Trace filter is enabled";
                }
    
                leaf forward-recursive {
                  type boolean;
                  description
                    "Recursive Forwarding is enabled";
                }
    
                leaf peer-change-delay {
                  type int32;
                  units "millisecond";
                  description
                    "Neighbor change delay in milli-seconds";
                }
    
                leaf encode-branch-id {
                  type uint32;
                  description
                    "Recursive FEC Encode LSM ID";
                }
    
                leaf decode-branch-id {
                  type uint32;
                  description
                    "Recursive FEC Decode LSM ID";
                }
    
                leaf upstream-neigbbor-count {
                  type uint32;
                  description
                    "Upstream MLDP neighbor count";
                }
    
                leaf downstream-branch-count {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type uint32;
                  description
                    "Downstream branch count";
                }
    
                list upstream-neighbor {
                  description
                    "Upstream neighbor List";
                  leaf lsm-id {
                    type uint32;
                    description "LSM ID";
                  }
    
                  leaf mldp-peer {
                    type string {
                      length "0..32";
                    }
                    description
                      "MLDP Neighbor Identity";
                  }
    
                  leaf mpls-local-label {
                    type uint32;
                    description "Local Label";
                  }
    
                  leaf mpls-label-upstream {
                    type uint32;
                    description "Remote Label";
                  }
    
                  leaf active {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "Neighbor is active";
                  }
    
                  leaf delete-pending {
                    type boolean;
                    description
                      "Neighbor is delete pending";
                  }
    
                  leaf checkpoint-stale {
                    type boolean;
                    description
                      "MLDP neighbor information via checkpoint";
                  }
    
                  leaf make-before-break-ack {
                    type boolean;
                    description
                      "Make-before-break ack received";
                  }
    
                  leaf make-before-break-ack-pending {
                    type boolean;
                    description
                      "Make-before-break ack pending";
                  }
    
                  leaf mfi-duplicate-ignore {
                    type boolean;
                    description
                      "MFI duplicate ignore by forwarding";
                  }
    
                  leaf peer-change-delay {
                    type int32;
                    units "millisecond";
                    description
                      "Neighbor change delay in milli-seconds";
                  }
    
                  leaf delete-delay {
                    type int32;
                    units "millisecond";
                    description
                      "Upstream neighbor delete delay in milli-seconds";
                  }
    
                  leaf interface-name {
                    type string {
                      length "0..65";
                    }
                    description "Root Interface";
                  }
    
                  leaf root-address-next-hop {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type inet:ipv4-address;
                    description
                      "Root next-hop address";
                  }
    
                  leaf up-time {
                    type uint32;
                    units "millisecond";
                    description
                      "Neighbor uptime in milli-seconds";
                  }
    
                  leaf state-change-time {
                    type uint32;
                    units "millisecond";
                    description
                      "State change time in milli-seconds";
                  }
    
                  leaf csi-accepting {
                    type boolean;
                    description
                      "If ACEL is CSI accepting";
                  }
                }  // list upstream-neighbor
    
                list branch {
                  description "Branch List";
                  leaf lsm-id {
                    type uint32;
                    description "LSM ID";
                  }
    
                  leaf branch-owner {
                    type string {
                      length "0..32";
                    }
                    description
                      "Branch owner string";
                  }
    
                  leaf up-time {
                    type uint32;
                    units "millisecond";
                    description
                      "Branch uptime in milli-seconds";
                  }
    
                  leaf graceful-restart-stale {
                    type boolean;
                    description
                      "Branch has been marked stale by graceful restart";
                  }
    
                  leaf graceful-restart-instance {
                    type uint32;
                    description
                      "Branch graceful restart instance";
                  }
    
                  leaf mpls-label {
                    type uint32;
                    description
                      "Branch Remote label";
                  }
    
                  leaf mpls-local-label-upstream {
                    type uint32;
                    description
                      "Branch Local label";
                  }
    
                  leaf head-lsm-id {
                    type uint32;
                    description "Head LSM ID";
                  }
    
                  leaf recursive-owner-id {
                    type uint32;
                    description
                      "Recursive Branch ownerLSM ID";
                  }
    
                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Branch next-hop address";
                  }
    
                  leaf interface-name {
                    type string {
                      length "0..65";
                    }
                    description
                      "Branch next-hop interface name";
                  }
    
                  leaf interface-down {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "Interface is down";
                  }
    
                  leaf egress-interface-name {
                    type string {
                      length "0..64";
                    }
                    description
                      "Egress interface name";
                  }
    
                  leaf vrf-name {
                    type string {
                      length "0..33";
                    }
                    description "VRF name";
                  }
    
                  leaf owner-id {
                    type uint32;
                    description
                      "Branch owner ID";
                  }
    
                  leaf egress {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "Branch is Egress";
                  }
    
                  leaf mfi-peek {
                    type boolean;
                    description
                      "Branch Peek is enabled";
                  }
    
                  leaf ingress {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "Branch is Ingress";
                  }
    
                  leaf ppmp {
                    type boolean;
                    description
                      "Branch PPMP is enabled";
                  }
    
                  leaf drop {
                    type boolean;
                    description
                      "Branch DROP is set";
                  }
    
                  leaf ordered-mode {
                    type boolean;
                    description
                      "Branch is enabled for ordered mode";
                  }
    
                  leaf mame-before-break-request {
                    type boolean;
                    description
                      "MBB request received on this branch";
                  }
    
                  leaf application-stale {
                    type boolean;
                    description
                      "Branch marked stale by application";
                  }
    
                  leaf mfi-duplicate-ignore {
                    type boolean;
                    description
                      "MFI duplicate ignore by forwarding";
                  }
    
                  leaf rpf-id {
                    type uint32;
                    description "Branch RPF ID";
                  }
    
                  leaf ldp-message-id {
                    type uint32;
                    description
                      "Branch LDP message ID";
                  }
    
                  leaf rd-name {
                    type string {
                      length "0..65";
                    }
                    description
                      "Recursive RD name";
                  }
                }  // list branch
              }  // list lsm-id
            }  // container lsm-ids
    
            container vrfs {
              description
                "VRF specific operational data";
              list vrf {
                key "vrf-name";
                description
                  "Operational data for given VRF";
                leaf vrf-name {
                  type xr:Cisco-ios-xr-string {
                    length "1..32";
                  }
                  description "VRF Name";
                }
    
                container neighbor-addresses {
                  description
                    "MLDP Neighbors Addresses";
                  list neighbor-address {
                    key "address";
                    description
                      "Neighbor Address Information";
                    leaf address {
                      type inet:ipv4-address-no-zone;
                      description
                        "The Neighbor IP address";
                    }
    
                    leaf address-xr {
                      type inet:ipv4-address;
                      description
                        "MLDP neighbor address";
                    }
    
                    list identity {
                      description
                        "Identity List";
                      leaf identity-string {
                        type string {
                          length "0..32";
                        }
                        description
                          "MLDP Identity";
                      }
                    }  // list identity
                  }  // list neighbor-address
                }  // container neighbor-addresses
    
                container databases {
                  description "MLDP Database";
                  list database {
                    key "lsp-type root-address opaque-type opaque-value-string";
                    description
                      "MLDP Database Information";
                    leaf lsp-type {
                      type Lsp;
                      description "LSP Type";
                    }
    
                    leaf root-address {
                      type inet:ipv4-address-no-zone;
                      description "Root address";
                    }
    
                    leaf opaque-type {
                      type Opaque;
                      description "Opaque Type";
                    }
    
                    leaf opaque-value-string {
                      type xr:Cisco-ios-xr-string {
                        length "1..255";
                      }
                      description "OpaqueValue";
                    }
    
                    leaf lsm-id-xr {
                      type uint32;
                      description "LSM ID";
                    }
    
                    leaf vrf-name {
                      type string {
                        length "0..256";
                      }
                      description "VRF name";
                    }
    
                    leaf up-time {
                      type uint32;
                      units "millisecond";
                      description
                        "Uptime in milli-seconds";
                    }
    
                    leaf tree-type {
                      type uint32;
                      description "Tree Type";
                    }
    
                    leaf root-address-xr {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type inet:ipv4-address;
                      description "Root address";
                    }
    
                    leaf we-are-root {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "We are the root";
                    }
    
                    leaf fec-opaque-length {
                      type uint32;
                      description
                        "FEC opaque length";
                    }
    
                    leaf opaque-decoded-string {
                      type string {
                        length "0..255";
                      }
                      description
                        "Opaque value decoded string";
                    }
    
                    leaf fec-value-length {
                      type uint32;
                      description
                        "FEC Value length";
                    }
    
                    leaf root-node-redundency-lsm-id {
                      type uint32;
                      description "RNR LSM-ID";
                    }
    
                    leaf root-node-redundency-active {
                      type boolean;
                      description "RNR Active";
                    }
    
                    leaf root-node-redundency-is-primary {
                      type boolean;
                      description
                        "RNR Primary is this entry";
                    }
    
                    leaf root-node-redundency-lsm-id-primary {
                      type uint32;
                      description
                        "RNR Primary LSM ID";
                    }
    
                    leaf root-node-redundency-root-address {
                      type inet:ipv4-address;
                      description
                        "RNR Root node address";
                    }
    
                    leaf root-node-redundency-candidate-string {
                      type string {
                        length "0..80";
                      }
                      description
                        "RNR candidate list";
                    }
    
                    leaf is-ldp-branch {
                      type boolean;
                      description "LDP Branch";
                    }
    
                    leaf is-local-branch {
                      type boolean;
                      description "Local Branch";
                    }
    
                    leaf is-local-interface {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "Local Interface";
                    }
    
                    leaf role-egress {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description "Role Egress";
                    }
    
                    leaf forwarding-peek {
                      type boolean;
                      description
                        "Peek is enabled";
                    }
    
                    leaf make-before-break-enabled {
                      type boolean;
                      description
                        "MBB feature is enabled";
                    }
    
                    leaf mo-frr-enabled {
                      type boolean;
                      description
                        "MoFRR feature is enabled";
                    }
    
                    leaf recursive-fec-enabled {
                      type boolean;
                      description
                        "Recursive FEC is enabled";
                    }
    
                    leaf trace-enabled {
                      type boolean;
                      description
                        "Trace filter is enabled";
                    }
    
                    leaf forward-recursive {
                      type boolean;
                      description
                        "Recursive Forwarding is enabled";
                    }
    
                    leaf peer-change-delay {
                      type int32;
                      units "millisecond";
                      description
                        "Neighbor change delay in milli-seconds";
                    }
    
                    leaf encode-branch-id {
                      type uint32;
                      description
                        "Recursive FEC Encode LSM ID";
                    }
    
                    leaf decode-branch-id {
                      type uint32;
                      description
                        "Recursive FEC Decode LSM ID";
                    }
    
                    leaf upstream-neigbbor-count {
                      type uint32;
                      description
                        "Upstream MLDP neighbor count";
                    }
    
                    leaf downstream-branch-count {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "Downstream branch count";
                    }
    
                    list upstream-neighbor {
                      description
                        "Upstream neighbor List";
                      leaf lsm-id {
                        type uint32;
                        description "LSM ID";
                      }
    
                      leaf mldp-peer {
                        type string {
                          length "0..32";
                        }
                        description
                          "MLDP Neighbor Identity";
                      }
    
                      leaf mpls-local-label {
                        type uint32;
                        description
                          "Local Label";
                      }
    
                      leaf mpls-label-upstream {
                        type uint32;
                        description
                          "Remote Label";
                      }
    
                      leaf active {
                        xr:event-telemetry "Subscribe Telemetry Event";
                        type boolean;
                        description
                          "Neighbor is active";
                      }
    
                      leaf delete-pending {
                        type boolean;
                        description
                          "Neighbor is delete pending";
                      }
    
                      leaf checkpoint-stale {
                        type boolean;
                        description
                          "MLDP neighbor information via checkpoint";
                      }
    
                      leaf make-before-break-ack {
                        type boolean;
                        description
                          "Make-before-break ack received";
                      }
    
                      leaf make-before-break-ack-pending {
                        type boolean;
                        description
                          "Make-before-break ack pending";
                      }
    
                      leaf mfi-duplicate-ignore {
                        type boolean;
                        description
                          "MFI duplicate ignore by forwarding";
                      }
    
                      leaf peer-change-delay {
                        type int32;
                        units "millisecond";
                        description
                          "Neighbor change delay in milli-seconds";
                      }
    
                      leaf delete-delay {
                        type int32;
                        units "millisecond";
                        description
                          "Upstream neighbor delete delay in milli-seconds";
                      }
    
                      leaf interface-name {
                        type string {
                          length "0..65";
                        }
                        description
                          "Root Interface";
                      }
    
                      leaf root-address-next-hop {
                        xr:event-telemetry "Subscribe Telemetry Event";
                        type inet:ipv4-address;
                        description
                          "Root next-hop address";
                      }
    
                      leaf up-time {
                        type uint32;
                        units "millisecond";
                        description
                          "Neighbor uptime in milli-seconds";
                      }
    
                      leaf state-change-time {
                        type uint32;
                        units "millisecond";
                        description
                          "State change time in milli-seconds";
                      }
    
                      leaf csi-accepting {
                        type boolean;
                        description
                          "If ACEL is CSI accepting";
                      }
                    }  // list upstream-neighbor
    
                    list branch {
                      description "Branch List";
                      leaf lsm-id {
                        type uint32;
                        description "LSM ID";
                      }
    
                      leaf branch-owner {
                        type string {
                          length "0..32";
                        }
                        description
                          "Branch owner string";
                      }
    
                      leaf up-time {
                        type uint32;
                        units "millisecond";
                        description
                          "Branch uptime in milli-seconds";
                      }
    
                      leaf graceful-restart-stale {
                        type boolean;
                        description
                          "Branch has been marked stale by graceful restart";
                      }
    
                      leaf graceful-restart-instance {
                        type uint32;
                        description
                          "Branch graceful restart instance";
                      }
    
                      leaf mpls-label {
                        type uint32;
                        description
                          "Branch Remote label";
                      }
    
                      leaf mpls-local-label-upstream {
                        type uint32;
                        description
                          "Branch Local label";
                      }
    
                      leaf head-lsm-id {
                        type uint32;
                        description
                          "Head LSM ID";
                      }
    
                      leaf recursive-owner-id {
                        type uint32;
                        description
                          "Recursive Branch ownerLSM ID";
                      }
    
                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "Branch next-hop address";
                      }
    
                      leaf interface-name {
                        type string {
                          length "0..65";
                        }
                        description
                          "Branch next-hop interface name";
                      }
    
                      leaf interface-down {
                        xr:event-telemetry "Subscribe Telemetry Event";
                        type boolean;
                        description
                          "Interface is down";
                      }
    
                      leaf egress-interface-name {
                        type string {
                          length "0..64";
                        }
                        description
                          "Egress interface name";
                      }
    
                      leaf vrf-name {
                        type string {
                          length "0..33";
                        }
                        description "VRF name";
                      }
    
                      leaf owner-id {
                        type uint32;
                        description
                          "Branch owner ID";
                      }
    
                      leaf egress {
                        xr:event-telemetry "Subscribe Telemetry Event";
                        type boolean;
                        description
                          "Branch is Egress";
                      }
    
                      leaf mfi-peek {
                        type boolean;
                        description
                          "Branch Peek is enabled";
                      }
    
                      leaf ingress {
                        xr:event-telemetry "Subscribe Telemetry Event";
                        type boolean;
                        description
                          "Branch is Ingress";
                      }
    
                      leaf ppmp {
                        type boolean;
                        description
                          "Branch PPMP is enabled";
                      }
    
                      leaf drop {
                        type boolean;
                        description
                          "Branch DROP is set";
                      }
    
                      leaf ordered-mode {
                        type boolean;
                        description
                          "Branch is enabled for ordered mode";
                      }
    
                      leaf mame-before-break-request {
                        type boolean;
                        description
                          "MBB request received on this branch";
                      }
    
                      leaf application-stale {
                        type boolean;
                        description
                          "Branch marked stale by application";
                      }
    
                      leaf mfi-duplicate-ignore {
                        type boolean;
                        description
                          "MFI duplicate ignore by forwarding";
                      }
    
                      leaf rpf-id {
                        type uint32;
                        description
                          "Branch RPF ID";
                      }
    
                      leaf ldp-message-id {
                        type uint32;
                        description
                          "Branch LDP message ID";
                      }
    
                      leaf rd-name {
                        type string {
                          length "0..65";
                        }
                        description
                          "Recursive RD name";
                      }
                    }  // list branch
                  }  // list database
                }  // container databases
    
                container root-addresses {
                  description "MLDP Root Table";
                  list root-address {
                    key "root-address";
                    description
                      "MLDP Root Information";
                    leaf root-address {
                      type inet:ipv4-address-no-zone;
                      description "Root address";
                    }
    
                    leaf address {
                      type inet:ipv4-address;
                      description "Root address";
                    }
    
                    leaf we-are-root {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "We are the root";
                    }
    
                    leaf checkpoint-stale {
                      type boolean;
                      description
                        "MLDP root information via checkpoint";
                    }
    
                    leaf via-bgp {
                      type boolean;
                      description
                        "Route learned via BGP";
                    }
    
                    leaf via-static {
                      type boolean;
                      description
                        "Route learned via Static";
                    }
    
                    leaf metric {
                      type uint32;
                      description "Metric";
                    }
    
                    leaf distance {
                      type uint32;
                      description "Distance";
                    }
    
                    leaf interface-name {
                      type string {
                        length "0..65";
                      }
                      description
                        "Root Interface";
                    }
    
                    leaf fec-count {
                      type uint32;
                      description
                        "LSP's linked to this root";
                    }
    
                    leaf recursice-fec-count {
                      type uint32;
                      description
                        "Recursive LSP's linked to this root";
                    }
    
                    leaf path-count {
                      type uint32;
                      description
                        "Paths to reach this root";
                    }
    
                    list root-path {
                      description
                        "Root path list";
                      leaf root-address {
                        type inet:ipv4-address;
                        description
                          "Root address";
                      }
    
                      leaf mldp-identity-string {
                        type string {
                          length "0..32";
                        }
                        description
                          "MLDP neighbor identity";
                      }
    
                      leaf checkpoint-stale {
                        type boolean;
                        description
                          "MLDP root path information via checkpoint";
                      }
    
                      leaf php-next-hop-address {
                        type inet:ipv4-address;
                        description
                          "Penultimate next-hop";
                      }
                    }  // list root-path
    
                    list root-ipmsi {
                      description
                        "Root I-PMSI list";
                      leaf next-hop-address-ipv4 {
                        type inet:ipv4-address;
                        description
                          "IPMSI IPv4 next-hop address";
                      }
    
                      leaf next-hop-address-ipv6 {
                        type inet:ipv4-address;
                        description
                          "IPMSI IPv6 next-hop address";
                      }
    
                      leaf rd-name {
                        type string {
                          length "0..65";
                        }
                        description "RD name";
                      }
                    }  // list root-ipmsi
                  }  // list root-address
                }  // container root-addresses
    
                container context {
                  description "MLDP Context";
                  leaf vrf-name {
                    type string {
                      length "0..33";
                    }
                    description "VRF name";
                  }
    
                  leaf active-table-name {
                    type string {
                      length "0..32";
                    }
                    description
                      "Active RIB Table Name for this VRF";
                  }
    
                  leaf lsp-count {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "Number of P2MP/MP2MP LSPs in the vrf";
                  }
    
                  leaf peer-count {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "Number of mLDP neighbors in the vrf";
                  }
    
                  leaf mu-rib-enabled {
                    type boolean;
                    description
                      "MuRIB is enabled";
                  }
    
                  leaf multi-path-upstream-enabled {
                    type boolean;
                    description
                      "Multi-path Upstream is enabled";
                  }
    
                  leaf multi-path-downstream-enabled {
                    type boolean;
                    description
                      "Multi-path Downstream is enabled";
                  }
    
                  leaf make-before-break-delay {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    units "millisecond";
                    description
                      "Make-before-break delay in milli-seconds";
                  }
    
                  leaf mldp-table-count {
                    type uint32;
                    description
                      "Number of mLDP tables";
                  }
    
                  list mldp-table {
                    description
                      "List of mLDP tables";
                    leaf table-name {
                      type string {
                        length "0..32";
                      }
                      description "Table name";
                    }
    
                    leaf rib-converged {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "RIB table converged";
                    }
    
                    leaf rib-table-id {
                      type uint32;
                      description "RIB Table ID";
                    }
                  }  // list mldp-table
                }  // container context
    
                container neighbors {
                  description "MLDP Neighbors";
                  list neighbor {
                    key "address";
                    description
                      "Neighbor Information";
                    leaf address {
                      type inet:ipv4-address-no-zone;
                      description
                        "The Neighbor IP address";
                    }
    
                    leaf identity-string {
                      type string {
                        length "0..32";
                      }
                      description
                        "MLDP Identity string";
                    }
    
                    leaf capabilities {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "MLDP neighbor capabilities";
                    }
    
                    leaf up-time {
                      type uint32;
                      units "millisecond";
                      description
                        "MLDP neighbor uptime in milli-seconds";
                    }
    
                    leaf down {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "MLDP neighbor is marked as down";
                    }
    
                    leaf target-adjacency {
                      type boolean;
                      description
                        "MLDP neighbor is targetted";
                    }
    
                    leaf session-handle {
                      type uint32;
                      description
                        "MLDP neighbor session handle";
                    }
    
                    leaf upstream-count {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "MLDP neighbor Upstream LSP count";
                    }
    
                    leaf branch-count {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "MLDP neighbor branch count";
                    }
    
                    leaf graceful-restart-enabled {
                      type boolean;
                      description
                        "Graceful restart enabled";
                    }
    
                    leaf graceful-restart-active {
                      type boolean;
                      description
                        "LDP is in Graceful restart mode";
                    }
    
                    leaf graceful-restart-instance {
                      type uint32;
                      description
                        "Graceful restart instance";
                    }
    
                    leaf graceful-restart-reconnect-time {
                      type uint32;
                      description
                        "GR reconnect time";
                    }
    
                    leaf label-map-timer {
                      type int32;
                      units "millisecond";
                      description
                        "Label Mapping timer in milli-seconds";
                    }
    
                    leaf checkpoint-stale {
                      type boolean;
                      description
                        "MLDP neighbor information via checkpoint";
                    }
    
                    leaf path-count {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "MLDP neighbor path count";
                    }
    
                    leaf adjacency-count {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "MLDP neighbor adjacency count";
                    }
    
                    leaf inbound-neighbor-policy {
                      type string {
                        length "0..256";
                      }
                      description
                        "Inbound Neighbor Policy";
                    }
    
                    leaf outbound-neighbor-policy {
                      type string {
                        length "0..256";
                      }
                      description
                        "Outbound Neighbor Policy";
                    }
    
                    leaf peer-identity-count {
                      type uint32;
                      description
                        "MLDP peer identify count";
                    }
    
                    list neighbor-path {
                      description "Path List";
                      leaf neighbor-address {
                        type inet:ipv4-address;
                        description
                          "MLDP neighbor path address";
                      }
    
                      leaf interface-name {
                        type string {
                          length "0..65";
                        }
                        description
                          "MLDP neighbor path interface";
                      }
    
                      leaf mldp-adjacency {
                        type boolean;
                        description
                          "MLDP adjacency present";
                      }
    
                      leaf checkpoint-stale {
                        type boolean;
                        description
                          "MLDP neighbor path info via checkpoint";
                      }
    
                      leaf disabled {
                        type uint32;
                        description
                          "MLDP neighbor path is disabled";
                      }
                    }  // list neighbor-path
    
                    list neighbor-adjacency {
                      description
                        "Adjacency List";
                      leaf address {
                        type inet:ipv4-address;
                        description
                          "MLDP neighbor adjacency address";
                      }
    
                      leaf interface-name {
                        type string {
                          length "0..65";
                        }
                        description
                          "MLDP neighbor adjacency interface";
                      }
    
                      leaf checkpoint-stale {
                        type boolean;
                        description
                          "MLDP neighbor adj info via checkpoint";
                      }
    
                      leaf graceful-restart-stale {
                        type boolean;
                        description
                          "MLDP neighbor adj stale due to GR";
                      }
    
                      leaf confict-ignore {
                        type boolean;
                        description
                          "Ignore this adjacency due to conflict";
                      }
                    }  // list neighbor-adjacency
    
                    list peer-identity {
                      description
                        "Identity List";
                      leaf address {
                        type inet:ipv4-address;
                        description
                          "MLDP neighbor identity address";
                      }
                    }  // list peer-identity
                  }  // list neighbor
                }  // container neighbors
              }  // list vrf
            }  // container vrfs
    
            container default-context {
              description
                "Default context specific operational data";
              container neighbor-addresses {
                description
                  "MLDP Neighbors Addresses";
                list neighbor-address {
                  key "address";
                  description
                    "Neighbor Address Information";
                  leaf address {
                    type inet:ipv4-address-no-zone;
                    description
                      "The Neighbor IP address";
                  }
    
                  leaf address-xr {
                    type inet:ipv4-address;
                    description
                      "MLDP neighbor address";
                  }
    
                  list identity {
                    description "Identity List";
                    leaf identity-string {
                      type string {
                        length "0..32";
                      }
                      description
                        "MLDP Identity";
                    }
                  }  // list identity
                }  // list neighbor-address
              }  // container neighbor-addresses
    
              container databases {
                description "MLDP Database";
                list database {
                  key "lsp-type root-address opaque-type opaque-value-string";
                  description
                    "MLDP Database Information";
                  leaf lsp-type {
                    type Lsp;
                    description "LSP Type";
                  }
    
                  leaf root-address {
                    type inet:ipv4-address-no-zone;
                    description "Root address";
                  }
    
                  leaf opaque-type {
                    type Opaque;
                    description "Opaque Type";
                  }
    
                  leaf opaque-value-string {
                    type xr:Cisco-ios-xr-string {
                      length "1..255";
                    }
                    description "OpaqueValue";
                  }
    
                  leaf lsm-id-xr {
                    type uint32;
                    description "LSM ID";
                  }
    
                  leaf vrf-name {
                    type string {
                      length "0..256";
                    }
                    description "VRF name";
                  }
    
                  leaf up-time {
                    type uint32;
                    units "millisecond";
                    description
                      "Uptime in milli-seconds";
                  }
    
                  leaf tree-type {
                    type uint32;
                    description "Tree Type";
                  }
    
                  leaf root-address-xr {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type inet:ipv4-address;
                    description "Root address";
                  }
    
                  leaf we-are-root {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "We are the root";
                  }
    
                  leaf fec-opaque-length {
                    type uint32;
                    description
                      "FEC opaque length";
                  }
    
                  leaf opaque-decoded-string {
                    type string {
                      length "0..255";
                    }
                    description
                      "Opaque value decoded string";
                  }
    
                  leaf fec-value-length {
                    type uint32;
                    description
                      "FEC Value length";
                  }
    
                  leaf root-node-redundency-lsm-id {
                    type uint32;
                    description "RNR LSM-ID";
                  }
    
                  leaf root-node-redundency-active {
                    type boolean;
                    description "RNR Active";
                  }
    
                  leaf root-node-redundency-is-primary {
                    type boolean;
                    description
                      "RNR Primary is this entry";
                  }
    
                  leaf root-node-redundency-lsm-id-primary {
                    type uint32;
                    description
                      "RNR Primary LSM ID";
                  }
    
                  leaf root-node-redundency-root-address {
                    type inet:ipv4-address;
                    description
                      "RNR Root node address";
                  }
    
                  leaf root-node-redundency-candidate-string {
                    type string {
                      length "0..80";
                    }
                    description
                      "RNR candidate list";
                  }
    
                  leaf is-ldp-branch {
                    type boolean;
                    description "LDP Branch";
                  }
    
                  leaf is-local-branch {
                    type boolean;
                    description "Local Branch";
                  }
    
                  leaf is-local-interface {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "Local Interface";
                  }
    
                  leaf role-egress {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description "Role Egress";
                  }
    
                  leaf forwarding-peek {
                    type boolean;
                    description
                      "Peek is enabled";
                  }
    
                  leaf make-before-break-enabled {
                    type boolean;
                    description
                      "MBB feature is enabled";
                  }
    
                  leaf mo-frr-enabled {
                    type boolean;
                    description
                      "MoFRR feature is enabled";
                  }
    
                  leaf recursive-fec-enabled {
                    type boolean;
                    description
                      "Recursive FEC is enabled";
                  }
    
                  leaf trace-enabled {
                    type boolean;
                    description
                      "Trace filter is enabled";
                  }
    
                  leaf forward-recursive {
                    type boolean;
                    description
                      "Recursive Forwarding is enabled";
                  }
    
                  leaf peer-change-delay {
                    type int32;
                    units "millisecond";
                    description
                      "Neighbor change delay in milli-seconds";
                  }
    
                  leaf encode-branch-id {
                    type uint32;
                    description
                      "Recursive FEC Encode LSM ID";
                  }
    
                  leaf decode-branch-id {
                    type uint32;
                    description
                      "Recursive FEC Decode LSM ID";
                  }
    
                  leaf upstream-neigbbor-count {
                    type uint32;
                    description
                      "Upstream MLDP neighbor count";
                  }
    
                  leaf downstream-branch-count {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "Downstream branch count";
                  }
    
                  list upstream-neighbor {
                    description
                      "Upstream neighbor List";
                    leaf lsm-id {
                      type uint32;
                      description "LSM ID";
                    }
    
                    leaf mldp-peer {
                      type string {
                        length "0..32";
                      }
                      description
                        "MLDP Neighbor Identity";
                    }
    
                    leaf mpls-local-label {
                      type uint32;
                      description "Local Label";
                    }
    
                    leaf mpls-label-upstream {
                      type uint32;
                      description "Remote Label";
                    }
    
                    leaf active {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "Neighbor is active";
                    }
    
                    leaf delete-pending {
                      type boolean;
                      description
                        "Neighbor is delete pending";
                    }
    
                    leaf checkpoint-stale {
                      type boolean;
                      description
                        "MLDP neighbor information via checkpoint";
                    }
    
                    leaf make-before-break-ack {
                      type boolean;
                      description
                        "Make-before-break ack received";
                    }
    
                    leaf make-before-break-ack-pending {
                      type boolean;
                      description
                        "Make-before-break ack pending";
                    }
    
                    leaf mfi-duplicate-ignore {
                      type boolean;
                      description
                        "MFI duplicate ignore by forwarding";
                    }
    
                    leaf peer-change-delay {
                      type int32;
                      units "millisecond";
                      description
                        "Neighbor change delay in milli-seconds";
                    }
    
                    leaf delete-delay {
                      type int32;
                      units "millisecond";
                      description
                        "Upstream neighbor delete delay in milli-seconds";
                    }
    
                    leaf interface-name {
                      type string {
                        length "0..65";
                      }
                      description
                        "Root Interface";
                    }
    
                    leaf root-address-next-hop {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type inet:ipv4-address;
                      description
                        "Root next-hop address";
                    }
    
                    leaf up-time {
                      type uint32;
                      units "millisecond";
                      description
                        "Neighbor uptime in milli-seconds";
                    }
    
                    leaf state-change-time {
                      type uint32;
                      units "millisecond";
                      description
                        "State change time in milli-seconds";
                    }
    
                    leaf csi-accepting {
                      type boolean;
                      description
                        "If ACEL is CSI accepting";
                    }
                  }  // list upstream-neighbor
    
                  list branch {
                    description "Branch List";
                    leaf lsm-id {
                      type uint32;
                      description "LSM ID";
                    }
    
                    leaf branch-owner {
                      type string {
                        length "0..32";
                      }
                      description
                        "Branch owner string";
                    }
    
                    leaf up-time {
                      type uint32;
                      units "millisecond";
                      description
                        "Branch uptime in milli-seconds";
                    }
    
                    leaf graceful-restart-stale {
                      type boolean;
                      description
                        "Branch has been marked stale by graceful restart";
                    }
    
                    leaf graceful-restart-instance {
                      type uint32;
                      description
                        "Branch graceful restart instance";
                    }
    
                    leaf mpls-label {
                      type uint32;
                      description
                        "Branch Remote label";
                    }
    
                    leaf mpls-local-label-upstream {
                      type uint32;
                      description
                        "Branch Local label";
                    }
    
                    leaf head-lsm-id {
                      type uint32;
                      description "Head LSM ID";
                    }
    
                    leaf recursive-owner-id {
                      type uint32;
                      description
                        "Recursive Branch ownerLSM ID";
                    }
    
                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "Branch next-hop address";
                    }
    
                    leaf interface-name {
                      type string {
                        length "0..65";
                      }
                      description
                        "Branch next-hop interface name";
                    }
    
                    leaf interface-down {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "Interface is down";
                    }
    
                    leaf egress-interface-name {
                      type string {
                        length "0..64";
                      }
                      description
                        "Egress interface name";
                    }
    
                    leaf vrf-name {
                      type string {
                        length "0..33";
                      }
                      description "VRF name";
                    }
    
                    leaf owner-id {
                      type uint32;
                      description
                        "Branch owner ID";
                    }
    
                    leaf egress {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "Branch is Egress";
                    }
    
                    leaf mfi-peek {
                      type boolean;
                      description
                        "Branch Peek is enabled";
                    }
    
                    leaf ingress {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "Branch is Ingress";
                    }
    
                    leaf ppmp {
                      type boolean;
                      description
                        "Branch PPMP is enabled";
                    }
    
                    leaf drop {
                      type boolean;
                      description
                        "Branch DROP is set";
                    }
    
                    leaf ordered-mode {
                      type boolean;
                      description
                        "Branch is enabled for ordered mode";
                    }
    
                    leaf mame-before-break-request {
                      type boolean;
                      description
                        "MBB request received on this branch";
                    }
    
                    leaf application-stale {
                      type boolean;
                      description
                        "Branch marked stale by application";
                    }
    
                    leaf mfi-duplicate-ignore {
                      type boolean;
                      description
                        "MFI duplicate ignore by forwarding";
                    }
    
                    leaf rpf-id {
                      type uint32;
                      description
                        "Branch RPF ID";
                    }
    
                    leaf ldp-message-id {
                      type uint32;
                      description
                        "Branch LDP message ID";
                    }
    
                    leaf rd-name {
                      type string {
                        length "0..65";
                      }
                      description
                        "Recursive RD name";
                    }
                  }  // list branch
                }  // list database
              }  // container databases
    
              container root-addresses {
                description "MLDP Root Table";
                list root-address {
                  key "root-address";
                  description
                    "MLDP Root Information";
                  leaf root-address {
                    type inet:ipv4-address-no-zone;
                    description "Root address";
                  }
    
                  leaf address {
                    type inet:ipv4-address;
                    description "Root address";
                  }
    
                  leaf we-are-root {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "We are the root";
                  }
    
                  leaf checkpoint-stale {
                    type boolean;
                    description
                      "MLDP root information via checkpoint";
                  }
    
                  leaf via-bgp {
                    type boolean;
                    description
                      "Route learned via BGP";
                  }
    
                  leaf via-static {
                    type boolean;
                    description
                      "Route learned via Static";
                  }
    
                  leaf metric {
                    type uint32;
                    description "Metric";
                  }
    
                  leaf distance {
                    type uint32;
                    description "Distance";
                  }
    
                  leaf interface-name {
                    type string {
                      length "0..65";
                    }
                    description "Root Interface";
                  }
    
                  leaf fec-count {
                    type uint32;
                    description
                      "LSP's linked to this root";
                  }
    
                  leaf recursice-fec-count {
                    type uint32;
                    description
                      "Recursive LSP's linked to this root";
                  }
    
                  leaf path-count {
                    type uint32;
                    description
                      "Paths to reach this root";
                  }
    
                  list root-path {
                    description "Root path list";
                    leaf root-address {
                      type inet:ipv4-address;
                      description "Root address";
                    }
    
                    leaf mldp-identity-string {
                      type string {
                        length "0..32";
                      }
                      description
                        "MLDP neighbor identity";
                    }
    
                    leaf checkpoint-stale {
                      type boolean;
                      description
                        "MLDP root path information via checkpoint";
                    }
    
                    leaf php-next-hop-address {
                      type inet:ipv4-address;
                      description
                        "Penultimate next-hop";
                    }
                  }  // list root-path
    
                  list root-ipmsi {
                    description
                      "Root I-PMSI list";
                    leaf next-hop-address-ipv4 {
                      type inet:ipv4-address;
                      description
                        "IPMSI IPv4 next-hop address";
                    }
    
                    leaf next-hop-address-ipv6 {
                      type inet:ipv4-address;
                      description
                        "IPMSI IPv6 next-hop address";
                    }
    
                    leaf rd-name {
                      type string {
                        length "0..65";
                      }
                      description "RD name";
                    }
                  }  // list root-ipmsi
                }  // list root-address
              }  // container root-addresses
    
              container context {
                description "MLDP Context";
                leaf vrf-name {
                  type string {
                    length "0..33";
                  }
                  description "VRF name";
                }
    
                leaf active-table-name {
                  type string {
                    length "0..32";
                  }
                  description
                    "Active RIB Table Name for this VRF";
                }
    
                leaf lsp-count {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type uint32;
                  description
                    "Number of P2MP/MP2MP LSPs in the vrf";
                }
    
                leaf peer-count {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type uint32;
                  description
                    "Number of mLDP neighbors in the vrf";
                }
    
                leaf mu-rib-enabled {
                  type boolean;
                  description "MuRIB is enabled";
                }
    
                leaf multi-path-upstream-enabled {
                  type boolean;
                  description
                    "Multi-path Upstream is enabled";
                }
    
                leaf multi-path-downstream-enabled {
                  type boolean;
                  description
                    "Multi-path Downstream is enabled";
                }
    
                leaf make-before-break-delay {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type uint32;
                  units "millisecond";
                  description
                    "Make-before-break delay in milli-seconds";
                }
    
                leaf mldp-table-count {
                  type uint32;
                  description
                    "Number of mLDP tables";
                }
    
                list mldp-table {
                  description
                    "List of mLDP tables";
                  leaf table-name {
                    type string {
                      length "0..32";
                    }
                    description "Table name";
                  }
    
                  leaf rib-converged {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "RIB table converged";
                  }
    
                  leaf rib-table-id {
                    type uint32;
                    description "RIB Table ID";
                  }
                }  // list mldp-table
              }  // container context
    
              container neighbors {
                description "MLDP Neighbors";
                list neighbor {
                  key "address";
                  description
                    "Neighbor Information";
                  leaf address {
                    type inet:ipv4-address-no-zone;
                    description
                      "The Neighbor IP address";
                  }
    
                  leaf identity-string {
                    type string {
                      length "0..32";
                    }
                    description
                      "MLDP Identity string";
                  }
    
                  leaf capabilities {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "MLDP neighbor capabilities";
                  }
    
                  leaf up-time {
                    type uint32;
                    units "millisecond";
                    description
                      "MLDP neighbor uptime in milli-seconds";
                  }
    
                  leaf down {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "MLDP neighbor is marked as down";
                  }
    
                  leaf target-adjacency {
                    type boolean;
                    description
                      "MLDP neighbor is targetted";
                  }
    
                  leaf session-handle {
                    type uint32;
                    description
                      "MLDP neighbor session handle";
                  }
    
                  leaf upstream-count {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "MLDP neighbor Upstream LSP count";
                  }
    
                  leaf branch-count {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "MLDP neighbor branch count";
                  }
    
                  leaf graceful-restart-enabled {
                    type boolean;
                    description
                      "Graceful restart enabled";
                  }
    
                  leaf graceful-restart-active {
                    type boolean;
                    description
                      "LDP is in Graceful restart mode";
                  }
    
                  leaf graceful-restart-instance {
                    type uint32;
                    description
                      "Graceful restart instance";
                  }
    
                  leaf graceful-restart-reconnect-time {
                    type uint32;
                    description
                      "GR reconnect time";
                  }
    
                  leaf label-map-timer {
                    type int32;
                    units "millisecond";
                    description
                      "Label Mapping timer in milli-seconds";
                  }
    
                  leaf checkpoint-stale {
                    type boolean;
                    description
                      "MLDP neighbor information via checkpoint";
                  }
    
                  leaf path-count {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "MLDP neighbor path count";
                  }
    
                  leaf adjacency-count {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "MLDP neighbor adjacency count";
                  }
    
                  leaf inbound-neighbor-policy {
                    type string {
                      length "0..256";
                    }
                    description
                      "Inbound Neighbor Policy";
                  }
    
                  leaf outbound-neighbor-policy {
                    type string {
                      length "0..256";
                    }
                    description
                      "Outbound Neighbor Policy";
                  }
    
                  leaf peer-identity-count {
                    type uint32;
                    description
                      "MLDP peer identify count";
                  }
    
                  list neighbor-path {
                    description "Path List";
                    leaf neighbor-address {
                      type inet:ipv4-address;
                      description
                        "MLDP neighbor path address";
                    }
    
                    leaf interface-name {
                      type string {
                        length "0..65";
                      }
                      description
                        "MLDP neighbor path interface";
                    }
    
                    leaf mldp-adjacency {
                      type boolean;
                      description
                        "MLDP adjacency present";
                    }
    
                    leaf checkpoint-stale {
                      type boolean;
                      description
                        "MLDP neighbor path info via checkpoint";
                    }
    
                    leaf disabled {
                      type uint32;
                      description
                        "MLDP neighbor path is disabled";
                    }
                  }  // list neighbor-path
    
                  list neighbor-adjacency {
                    description "Adjacency List";
                    leaf address {
                      type inet:ipv4-address;
                      description
                        "MLDP neighbor adjacency address";
                    }
    
                    leaf interface-name {
                      type string {
                        length "0..65";
                      }
                      description
                        "MLDP neighbor adjacency interface";
                    }
    
                    leaf checkpoint-stale {
                      type boolean;
                      description
                        "MLDP neighbor adj info via checkpoint";
                    }
    
                    leaf graceful-restart-stale {
                      type boolean;
                      description
                        "MLDP neighbor adj stale due to GR";
                    }
    
                    leaf confict-ignore {
                      type boolean;
                      description
                        "Ignore this adjacency due to conflict";
                    }
                  }  // list neighbor-adjacency
    
                  list peer-identity {
                    description "Identity List";
                    leaf address {
                      type inet:ipv4-address;
                      description
                        "MLDP neighbor identity address";
                    }
                  }  // list peer-identity
                }  // list neighbor
              }  // container neighbors
            }  // container default-context
          }  // container active
    
          container standby {
            description
              "Standby MPLS MLDP operational data";
            container status {
              description "MLDP Status";
              leaf mldp-active {
                type boolean;
                description
                  "MLDP has been activated";
              }
    
              leaf mldp-running {
                type boolean;
                description "MLDP is running";
              }
    
              leaf mldp-ready {
                type boolean;
                description "MLDP is ready";
              }
    
              leaf mldp-rib-connection-status {
                type boolean;
                description
                  "MLDP RIB connection status";
              }
    
              leaf mldp-rib-connection-open {
                type boolean;
                description
                  "MLDP RIB connection open";
              }
    
              leaf log-internal {
                type boolean;
                description
                  "Logging internal is enabled";
              }
    
              leaf log-notifications {
                type boolean;
                description
                  "Logging notifications is enabled";
              }
    
              leaf label-release-delay {
                type uint32;
                units "millisecond";
                description
                  "Label release delay in milli-seconds";
              }
    
              leaf lsm-id-delay {
                type uint32;
                units "millisecond";
                description
                  "LSM ID scan delay in milli-seconds";
              }
            }  // container status
    
            container mfi-entries {
              description "MLDP MFI Table";
              list mfi-entry {
                key "mpls-label";
                description
                  "MLDP MFI Information";
                leaf mpls-label {
                  type uint32;
                  description "MPLS Label";
                }
    
                leaf mpls-local-label {
                  type uint32;
                  description "Local Label";
                }
    
                leaf lsm-id {
                  type uint32;
                  description "LSM ID";
                }
    
                leaf head-lsm-id {
                  type uint32;
                  description "Head LSM ID";
                }
    
                leaf flags {
                  type uint32;
                  description "Flags";
                }
    
                leaf rpf-id {
                  type uint32;
                  description "RPF Identifier";
                }
    
                leaf interface-name {
                  type string {
                    length "0..65";
                  }
                  description
                    "LSP Virtual interface name";
                }
    
                list forwarding-path {
                  description "Path List";
                  leaf mpls-label {
                    type uint32;
                    description "Remote Label";
                  }
    
                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description "Next hop";
                  }
    
                  leaf interface-name {
                    type string {
                      length "0..65";
                    }
                    description "Interface name";
                  }
    
                  leaf out-info-flags {
                    type uint32;
                    description "Outinfo flags";
                  }
    
                  leaf role {
                    type uint32;
                    description "Role";
                  }
                }  // list forwarding-path
              }  // list mfi-entry
            }  // container mfi-entries
    
            container lsp-bindings {
              description
                "MLDP LSP Bindings Table";
              list lsp-binding {
                key "lsm-id";
                description
                  "MLDP LSP Binding Information";
                leaf lsm-id {
                  type uint32;
                  description "LSM ID";
                }
    
                leaf binding-id {
                  type uint32;
                  description
                    "ID used for this binding";
                }
    
                leaf num-paths {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type uint32;
                  description
                    "Number of paths in this LSP binding";
                }
    
                list opaque {
                  description "FEC Opaque List";
                  leaf tree-type {
                    type uint32;
                    description "Tree Type";
                  }
    
                  leaf lsmid {
                    type uint32;
                    description
                      "LSM ID of the paths in this LSP binding";
                  }
    
                  leaf root-address {
                    type inet:ipv4-address;
                    description "Root address";
                  }
    
                  leaf opaque-decoded-string {
                    type string {
                      length "0..255";
                    }
                    description
                      "Opaque value decoded string";
                  }
                }  // list opaque
    
                list binding-path {
                  description "Path List";
                  leaf lsmid {
                    type uint32;
                    description
                      "LSM ID of the paths in this LSP binding";
                  }
    
                  leaf acel-type {
                    type boolean;
                    description
                      "Binding is Accepting Element";
                  }
    
                  leaf branch-type {
                    type boolean;
                    description
                      "Binding is a branch";
                  }
    
                  leaf acel-active {
                    type boolean;
                    description
                      "This ACEL is active";
                  }
    
                  leaf branch-owner-type {
                    type uint32;
                    description
                      "Which type of branch";
                  }
    
                  leaf local-label {
                    type uint32;
                    description
                      "Local label allocated for this binding";
                  }
    
                  leaf remote-label {
                    type uint32;
                    description
                      "Remote label assigned to this binding";
                  }
    
                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next-hop address";
                  }
    
                  leaf rpf-id {
                    type uint32;
                    description "RPF Identifier";
                  }
    
                  leaf interface-name {
                    type string {
                      length "0..65";
                    }
                    description "Interface name";
                  }
                }  // list binding-path
              }  // list lsp-binding
            }  // container lsp-bindings
    
            container lsm-ids {
              description "MLDP LSM-ID";
              list lsm-id {
                key "lsm-id";
                description
                  "MLDP LSMID Information";
                leaf lsm-id {
                  type uint32;
                  description "LSM ID";
                }
    
                leaf lsm-id-xr {
                  type uint32;
                  description "LSM ID";
                }
    
                leaf vrf-name {
                  type string {
                    length "0..256";
                  }
                  description "VRF name";
                }
    
                leaf up-time {
                  type uint32;
                  units "millisecond";
                  description
                    "Uptime in milli-seconds";
                }
    
                leaf tree-type {
                  type uint32;
                  description "Tree Type";
                }
    
                leaf root-address-xr {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type inet:ipv4-address;
                  description "Root address";
                }
    
                leaf we-are-root {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type boolean;
                  description "We are the root";
                }
    
                leaf fec-opaque-length {
                  type uint32;
                  description
                    "FEC opaque length";
                }
    
                leaf opaque-decoded-string {
                  type string {
                    length "0..255";
                  }
                  description
                    "Opaque value decoded string";
                }
    
                leaf fec-value-length {
                  type uint32;
                  description "FEC Value length";
                }
    
                leaf root-node-redundency-lsm-id {
                  type uint32;
                  description "RNR LSM-ID";
                }
    
                leaf root-node-redundency-active {
                  type boolean;
                  description "RNR Active";
                }
    
                leaf root-node-redundency-is-primary {
                  type boolean;
                  description
                    "RNR Primary is this entry";
                }
    
                leaf root-node-redundency-lsm-id-primary {
                  type uint32;
                  description
                    "RNR Primary LSM ID";
                }
    
                leaf root-node-redundency-root-address {
                  type inet:ipv4-address;
                  description
                    "RNR Root node address";
                }
    
                leaf root-node-redundency-candidate-string {
                  type string {
                    length "0..80";
                  }
                  description
                    "RNR candidate list";
                }
    
                leaf is-ldp-branch {
                  type boolean;
                  description "LDP Branch";
                }
    
                leaf is-local-branch {
                  type boolean;
                  description "Local Branch";
                }
    
                leaf is-local-interface {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type boolean;
                  description "Local Interface";
                }
    
                leaf role-egress {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type boolean;
                  description "Role Egress";
                }
    
                leaf forwarding-peek {
                  type boolean;
                  description "Peek is enabled";
                }
    
                leaf make-before-break-enabled {
                  type boolean;
                  description
                    "MBB feature is enabled";
                }
    
                leaf mo-frr-enabled {
                  type boolean;
                  description
                    "MoFRR feature is enabled";
                }
    
                leaf recursive-fec-enabled {
                  type boolean;
                  description
                    "Recursive FEC is enabled";
                }
    
                leaf trace-enabled {
                  type boolean;
                  description
                    "Trace filter is enabled";
                }
    
                leaf forward-recursive {
                  type boolean;
                  description
                    "Recursive Forwarding is enabled";
                }
    
                leaf peer-change-delay {
                  type int32;
                  units "millisecond";
                  description
                    "Neighbor change delay in milli-seconds";
                }
    
                leaf encode-branch-id {
                  type uint32;
                  description
                    "Recursive FEC Encode LSM ID";
                }
    
                leaf decode-branch-id {
                  type uint32;
                  description
                    "Recursive FEC Decode LSM ID";
                }
    
                leaf upstream-neigbbor-count {
                  type uint32;
                  description
                    "Upstream MLDP neighbor count";
                }
    
                leaf downstream-branch-count {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type uint32;
                  description
                    "Downstream branch count";
                }
    
                list upstream-neighbor {
                  description
                    "Upstream neighbor List";
                  leaf lsm-id {
                    type uint32;
                    description "LSM ID";
                  }
    
                  leaf mldp-peer {
                    type string {
                      length "0..32";
                    }
                    description
                      "MLDP Neighbor Identity";
                  }
    
                  leaf mpls-local-label {
                    type uint32;
                    description "Local Label";
                  }
    
                  leaf mpls-label-upstream {
                    type uint32;
                    description "Remote Label";
                  }
    
                  leaf active {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "Neighbor is active";
                  }
    
                  leaf delete-pending {
                    type boolean;
                    description
                      "Neighbor is delete pending";
                  }
    
                  leaf checkpoint-stale {
                    type boolean;
                    description
                      "MLDP neighbor information via checkpoint";
                  }
    
                  leaf make-before-break-ack {
                    type boolean;
                    description
                      "Make-before-break ack received";
                  }
    
                  leaf make-before-break-ack-pending {
                    type boolean;
                    description
                      "Make-before-break ack pending";
                  }
    
                  leaf mfi-duplicate-ignore {
                    type boolean;
                    description
                      "MFI duplicate ignore by forwarding";
                  }
    
                  leaf peer-change-delay {
                    type int32;
                    units "millisecond";
                    description
                      "Neighbor change delay in milli-seconds";
                  }
    
                  leaf delete-delay {
                    type int32;
                    units "millisecond";
                    description
                      "Upstream neighbor delete delay in milli-seconds";
                  }
    
                  leaf interface-name {
                    type string {
                      length "0..65";
                    }
                    description "Root Interface";
                  }
    
                  leaf root-address-next-hop {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type inet:ipv4-address;
                    description
                      "Root next-hop address";
                  }
    
                  leaf up-time {
                    type uint32;
                    units "millisecond";
                    description
                      "Neighbor uptime in milli-seconds";
                  }
    
                  leaf state-change-time {
                    type uint32;
                    units "millisecond";
                    description
                      "State change time in milli-seconds";
                  }
    
                  leaf csi-accepting {
                    type boolean;
                    description
                      "If ACEL is CSI accepting";
                  }
                }  // list upstream-neighbor
    
                list branch {
                  description "Branch List";
                  leaf lsm-id {
                    type uint32;
                    description "LSM ID";
                  }
    
                  leaf branch-owner {
                    type string {
                      length "0..32";
                    }
                    description
                      "Branch owner string";
                  }
    
                  leaf up-time {
                    type uint32;
                    units "millisecond";
                    description
                      "Branch uptime in milli-seconds";
                  }
    
                  leaf graceful-restart-stale {
                    type boolean;
                    description
                      "Branch has been marked stale by graceful restart";
                  }
    
                  leaf graceful-restart-instance {
                    type uint32;
                    description
                      "Branch graceful restart instance";
                  }
    
                  leaf mpls-label {
                    type uint32;
                    description
                      "Branch Remote label";
                  }
    
                  leaf mpls-local-label-upstream {
                    type uint32;
                    description
                      "Branch Local label";
                  }
    
                  leaf head-lsm-id {
                    type uint32;
                    description "Head LSM ID";
                  }
    
                  leaf recursive-owner-id {
                    type uint32;
                    description
                      "Recursive Branch ownerLSM ID";
                  }
    
                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Branch next-hop address";
                  }
    
                  leaf interface-name {
                    type string {
                      length "0..65";
                    }
                    description
                      "Branch next-hop interface name";
                  }
    
                  leaf interface-down {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "Interface is down";
                  }
    
                  leaf egress-interface-name {
                    type string {
                      length "0..64";
                    }
                    description
                      "Egress interface name";
                  }
    
                  leaf vrf-name {
                    type string {
                      length "0..33";
                    }
                    description "VRF name";
                  }
    
                  leaf owner-id {
                    type uint32;
                    description
                      "Branch owner ID";
                  }
    
                  leaf egress {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "Branch is Egress";
                  }
    
                  leaf mfi-peek {
                    type boolean;
                    description
                      "Branch Peek is enabled";
                  }
    
                  leaf ingress {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "Branch is Ingress";
                  }
    
                  leaf ppmp {
                    type boolean;
                    description
                      "Branch PPMP is enabled";
                  }
    
                  leaf drop {
                    type boolean;
                    description
                      "Branch DROP is set";
                  }
    
                  leaf ordered-mode {
                    type boolean;
                    description
                      "Branch is enabled for ordered mode";
                  }
    
                  leaf mame-before-break-request {
                    type boolean;
                    description
                      "MBB request received on this branch";
                  }
    
                  leaf application-stale {
                    type boolean;
                    description
                      "Branch marked stale by application";
                  }
    
                  leaf mfi-duplicate-ignore {
                    type boolean;
                    description
                      "MFI duplicate ignore by forwarding";
                  }
    
                  leaf rpf-id {
                    type uint32;
                    description "Branch RPF ID";
                  }
    
                  leaf ldp-message-id {
                    type uint32;
                    description
                      "Branch LDP message ID";
                  }
    
                  leaf rd-name {
                    type string {
                      length "0..65";
                    }
                    description
                      "Recursive RD name";
                  }
                }  // list branch
              }  // list lsm-id
            }  // container lsm-ids
    
            container vrfs {
              description
                "VRF specific operational data";
              list vrf {
                key "vrf-name";
                description
                  "Operational data for given VRF";
                leaf vrf-name {
                  type xr:Cisco-ios-xr-string {
                    length "1..32";
                  }
                  description "VRF Name";
                }
    
                container neighbor-addresses {
                  description
                    "MLDP Neighbors Addresses";
                  list neighbor-address {
                    key "address";
                    description
                      "Neighbor Address Information";
                    leaf address {
                      type inet:ipv4-address-no-zone;
                      description
                        "The Neighbor IP address";
                    }
    
                    leaf address-xr {
                      type inet:ipv4-address;
                      description
                        "MLDP neighbor address";
                    }
    
                    list identity {
                      description
                        "Identity List";
                      leaf identity-string {
                        type string {
                          length "0..32";
                        }
                        description
                          "MLDP Identity";
                      }
                    }  // list identity
                  }  // list neighbor-address
                }  // container neighbor-addresses
    
                container databases {
                  description "MLDP Database";
                  list database {
                    key "lsp-type root-address opaque-type opaque-value-string";
                    description
                      "MLDP Database Information";
                    leaf lsp-type {
                      type Lsp;
                      description "LSP Type";
                    }
    
                    leaf root-address {
                      type inet:ipv4-address-no-zone;
                      description "Root address";
                    }
    
                    leaf opaque-type {
                      type Opaque;
                      description "Opaque Type";
                    }
    
                    leaf opaque-value-string {
                      type xr:Cisco-ios-xr-string {
                        length "1..255";
                      }
                      description "OpaqueValue";
                    }
    
                    leaf lsm-id-xr {
                      type uint32;
                      description "LSM ID";
                    }
    
                    leaf vrf-name {
                      type string {
                        length "0..256";
                      }
                      description "VRF name";
                    }
    
                    leaf up-time {
                      type uint32;
                      units "millisecond";
                      description
                        "Uptime in milli-seconds";
                    }
    
                    leaf tree-type {
                      type uint32;
                      description "Tree Type";
                    }
    
                    leaf root-address-xr {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type inet:ipv4-address;
                      description "Root address";
                    }
    
                    leaf we-are-root {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "We are the root";
                    }
    
                    leaf fec-opaque-length {
                      type uint32;
                      description
                        "FEC opaque length";
                    }
    
                    leaf opaque-decoded-string {
                      type string {
                        length "0..255";
                      }
                      description
                        "Opaque value decoded string";
                    }
    
                    leaf fec-value-length {
                      type uint32;
                      description
                        "FEC Value length";
                    }
    
                    leaf root-node-redundency-lsm-id {
                      type uint32;
                      description "RNR LSM-ID";
                    }
    
                    leaf root-node-redundency-active {
                      type boolean;
                      description "RNR Active";
                    }
    
                    leaf root-node-redundency-is-primary {
                      type boolean;
                      description
                        "RNR Primary is this entry";
                    }
    
                    leaf root-node-redundency-lsm-id-primary {
                      type uint32;
                      description
                        "RNR Primary LSM ID";
                    }
    
                    leaf root-node-redundency-root-address {
                      type inet:ipv4-address;
                      description
                        "RNR Root node address";
                    }
    
                    leaf root-node-redundency-candidate-string {
                      type string {
                        length "0..80";
                      }
                      description
                        "RNR candidate list";
                    }
    
                    leaf is-ldp-branch {
                      type boolean;
                      description "LDP Branch";
                    }
    
                    leaf is-local-branch {
                      type boolean;
                      description "Local Branch";
                    }
    
                    leaf is-local-interface {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "Local Interface";
                    }
    
                    leaf role-egress {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description "Role Egress";
                    }
    
                    leaf forwarding-peek {
                      type boolean;
                      description
                        "Peek is enabled";
                    }
    
                    leaf make-before-break-enabled {
                      type boolean;
                      description
                        "MBB feature is enabled";
                    }
    
                    leaf mo-frr-enabled {
                      type boolean;
                      description
                        "MoFRR feature is enabled";
                    }
    
                    leaf recursive-fec-enabled {
                      type boolean;
                      description
                        "Recursive FEC is enabled";
                    }
    
                    leaf trace-enabled {
                      type boolean;
                      description
                        "Trace filter is enabled";
                    }
    
                    leaf forward-recursive {
                      type boolean;
                      description
                        "Recursive Forwarding is enabled";
                    }
    
                    leaf peer-change-delay {
                      type int32;
                      units "millisecond";
                      description
                        "Neighbor change delay in milli-seconds";
                    }
    
                    leaf encode-branch-id {
                      type uint32;
                      description
                        "Recursive FEC Encode LSM ID";
                    }
    
                    leaf decode-branch-id {
                      type uint32;
                      description
                        "Recursive FEC Decode LSM ID";
                    }
    
                    leaf upstream-neigbbor-count {
                      type uint32;
                      description
                        "Upstream MLDP neighbor count";
                    }
    
                    leaf downstream-branch-count {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "Downstream branch count";
                    }
    
                    list upstream-neighbor {
                      description
                        "Upstream neighbor List";
                      leaf lsm-id {
                        type uint32;
                        description "LSM ID";
                      }
    
                      leaf mldp-peer {
                        type string {
                          length "0..32";
                        }
                        description
                          "MLDP Neighbor Identity";
                      }
    
                      leaf mpls-local-label {
                        type uint32;
                        description
                          "Local Label";
                      }
    
                      leaf mpls-label-upstream {
                        type uint32;
                        description
                          "Remote Label";
                      }
    
                      leaf active {
                        xr:event-telemetry "Subscribe Telemetry Event";
                        type boolean;
                        description
                          "Neighbor is active";
                      }
    
                      leaf delete-pending {
                        type boolean;
                        description
                          "Neighbor is delete pending";
                      }
    
                      leaf checkpoint-stale {
                        type boolean;
                        description
                          "MLDP neighbor information via checkpoint";
                      }
    
                      leaf make-before-break-ack {
                        type boolean;
                        description
                          "Make-before-break ack received";
                      }
    
                      leaf make-before-break-ack-pending {
                        type boolean;
                        description
                          "Make-before-break ack pending";
                      }
    
                      leaf mfi-duplicate-ignore {
                        type boolean;
                        description
                          "MFI duplicate ignore by forwarding";
                      }
    
                      leaf peer-change-delay {
                        type int32;
                        units "millisecond";
                        description
                          "Neighbor change delay in milli-seconds";
                      }
    
                      leaf delete-delay {
                        type int32;
                        units "millisecond";
                        description
                          "Upstream neighbor delete delay in milli-seconds";
                      }
    
                      leaf interface-name {
                        type string {
                          length "0..65";
                        }
                        description
                          "Root Interface";
                      }
    
                      leaf root-address-next-hop {
                        xr:event-telemetry "Subscribe Telemetry Event";
                        type inet:ipv4-address;
                        description
                          "Root next-hop address";
                      }
    
                      leaf up-time {
                        type uint32;
                        units "millisecond";
                        description
                          "Neighbor uptime in milli-seconds";
                      }
    
                      leaf state-change-time {
                        type uint32;
                        units "millisecond";
                        description
                          "State change time in milli-seconds";
                      }
    
                      leaf csi-accepting {
                        type boolean;
                        description
                          "If ACEL is CSI accepting";
                      }
                    }  // list upstream-neighbor
    
                    list branch {
                      description "Branch List";
                      leaf lsm-id {
                        type uint32;
                        description "LSM ID";
                      }
    
                      leaf branch-owner {
                        type string {
                          length "0..32";
                        }
                        description
                          "Branch owner string";
                      }
    
                      leaf up-time {
                        type uint32;
                        units "millisecond";
                        description
                          "Branch uptime in milli-seconds";
                      }
    
                      leaf graceful-restart-stale {
                        type boolean;
                        description
                          "Branch has been marked stale by graceful restart";
                      }
    
                      leaf graceful-restart-instance {
                        type uint32;
                        description
                          "Branch graceful restart instance";
                      }
    
                      leaf mpls-label {
                        type uint32;
                        description
                          "Branch Remote label";
                      }
    
                      leaf mpls-local-label-upstream {
                        type uint32;
                        description
                          "Branch Local label";
                      }
    
                      leaf head-lsm-id {
                        type uint32;
                        description
                          "Head LSM ID";
                      }
    
                      leaf recursive-owner-id {
                        type uint32;
                        description
                          "Recursive Branch ownerLSM ID";
                      }
    
                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "Branch next-hop address";
                      }
    
                      leaf interface-name {
                        type string {
                          length "0..65";
                        }
                        description
                          "Branch next-hop interface name";
                      }
    
                      leaf interface-down {
                        xr:event-telemetry "Subscribe Telemetry Event";
                        type boolean;
                        description
                          "Interface is down";
                      }
    
                      leaf egress-interface-name {
                        type string {
                          length "0..64";
                        }
                        description
                          "Egress interface name";
                      }
    
                      leaf vrf-name {
                        type string {
                          length "0..33";
                        }
                        description "VRF name";
                      }
    
                      leaf owner-id {
                        type uint32;
                        description
                          "Branch owner ID";
                      }
    
                      leaf egress {
                        xr:event-telemetry "Subscribe Telemetry Event";
                        type boolean;
                        description
                          "Branch is Egress";
                      }
    
                      leaf mfi-peek {
                        type boolean;
                        description
                          "Branch Peek is enabled";
                      }
    
                      leaf ingress {
                        xr:event-telemetry "Subscribe Telemetry Event";
                        type boolean;
                        description
                          "Branch is Ingress";
                      }
    
                      leaf ppmp {
                        type boolean;
                        description
                          "Branch PPMP is enabled";
                      }
    
                      leaf drop {
                        type boolean;
                        description
                          "Branch DROP is set";
                      }
    
                      leaf ordered-mode {
                        type boolean;
                        description
                          "Branch is enabled for ordered mode";
                      }
    
                      leaf mame-before-break-request {
                        type boolean;
                        description
                          "MBB request received on this branch";
                      }
    
                      leaf application-stale {
                        type boolean;
                        description
                          "Branch marked stale by application";
                      }
    
                      leaf mfi-duplicate-ignore {
                        type boolean;
                        description
                          "MFI duplicate ignore by forwarding";
                      }
    
                      leaf rpf-id {
                        type uint32;
                        description
                          "Branch RPF ID";
                      }
    
                      leaf ldp-message-id {
                        type uint32;
                        description
                          "Branch LDP message ID";
                      }
    
                      leaf rd-name {
                        type string {
                          length "0..65";
                        }
                        description
                          "Recursive RD name";
                      }
                    }  // list branch
                  }  // list database
                }  // container databases
    
                container root-addresses {
                  description "MLDP Root Table";
                  list root-address {
                    key "root-address";
                    description
                      "MLDP Root Information";
                    leaf root-address {
                      type inet:ipv4-address-no-zone;
                      description "Root address";
                    }
    
                    leaf address {
                      type inet:ipv4-address;
                      description "Root address";
                    }
    
                    leaf we-are-root {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "We are the root";
                    }
    
                    leaf checkpoint-stale {
                      type boolean;
                      description
                        "MLDP root information via checkpoint";
                    }
    
                    leaf via-bgp {
                      type boolean;
                      description
                        "Route learned via BGP";
                    }
    
                    leaf via-static {
                      type boolean;
                      description
                        "Route learned via Static";
                    }
    
                    leaf metric {
                      type uint32;
                      description "Metric";
                    }
    
                    leaf distance {
                      type uint32;
                      description "Distance";
                    }
    
                    leaf interface-name {
                      type string {
                        length "0..65";
                      }
                      description
                        "Root Interface";
                    }
    
                    leaf fec-count {
                      type uint32;
                      description
                        "LSP's linked to this root";
                    }
    
                    leaf recursice-fec-count {
                      type uint32;
                      description
                        "Recursive LSP's linked to this root";
                    }
    
                    leaf path-count {
                      type uint32;
                      description
                        "Paths to reach this root";
                    }
    
                    list root-path {
                      description
                        "Root path list";
                      leaf root-address {
                        type inet:ipv4-address;
                        description
                          "Root address";
                      }
    
                      leaf mldp-identity-string {
                        type string {
                          length "0..32";
                        }
                        description
                          "MLDP neighbor identity";
                      }
    
                      leaf checkpoint-stale {
                        type boolean;
                        description
                          "MLDP root path information via checkpoint";
                      }
    
                      leaf php-next-hop-address {
                        type inet:ipv4-address;
                        description
                          "Penultimate next-hop";
                      }
                    }  // list root-path
    
                    list root-ipmsi {
                      description
                        "Root I-PMSI list";
                      leaf next-hop-address-ipv4 {
                        type inet:ipv4-address;
                        description
                          "IPMSI IPv4 next-hop address";
                      }
    
                      leaf next-hop-address-ipv6 {
                        type inet:ipv4-address;
                        description
                          "IPMSI IPv6 next-hop address";
                      }
    
                      leaf rd-name {
                        type string {
                          length "0..65";
                        }
                        description "RD name";
                      }
                    }  // list root-ipmsi
                  }  // list root-address
                }  // container root-addresses
    
                container context {
                  description "MLDP Context";
                  leaf vrf-name {
                    type string {
                      length "0..33";
                    }
                    description "VRF name";
                  }
    
                  leaf active-table-name {
                    type string {
                      length "0..32";
                    }
                    description
                      "Active RIB Table Name for this VRF";
                  }
    
                  leaf lsp-count {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "Number of P2MP/MP2MP LSPs in the vrf";
                  }
    
                  leaf peer-count {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "Number of mLDP neighbors in the vrf";
                  }
    
                  leaf mu-rib-enabled {
                    type boolean;
                    description
                      "MuRIB is enabled";
                  }
    
                  leaf multi-path-upstream-enabled {
                    type boolean;
                    description
                      "Multi-path Upstream is enabled";
                  }
    
                  leaf multi-path-downstream-enabled {
                    type boolean;
                    description
                      "Multi-path Downstream is enabled";
                  }
    
                  leaf make-before-break-delay {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    units "millisecond";
                    description
                      "Make-before-break delay in milli-seconds";
                  }
    
                  leaf mldp-table-count {
                    type uint32;
                    description
                      "Number of mLDP tables";
                  }
    
                  list mldp-table {
                    description
                      "List of mLDP tables";
                    leaf table-name {
                      type string {
                        length "0..32";
                      }
                      description "Table name";
                    }
    
                    leaf rib-converged {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "RIB table converged";
                    }
    
                    leaf rib-table-id {
                      type uint32;
                      description "RIB Table ID";
                    }
                  }  // list mldp-table
                }  // container context
    
                container neighbors {
                  description "MLDP Neighbors";
                  list neighbor {
                    key "address";
                    description
                      "Neighbor Information";
                    leaf address {
                      type inet:ipv4-address-no-zone;
                      description
                        "The Neighbor IP address";
                    }
    
                    leaf identity-string {
                      type string {
                        length "0..32";
                      }
                      description
                        "MLDP Identity string";
                    }
    
                    leaf capabilities {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "MLDP neighbor capabilities";
                    }
    
                    leaf up-time {
                      type uint32;
                      units "millisecond";
                      description
                        "MLDP neighbor uptime in milli-seconds";
                    }
    
                    leaf down {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "MLDP neighbor is marked as down";
                    }
    
                    leaf target-adjacency {
                      type boolean;
                      description
                        "MLDP neighbor is targetted";
                    }
    
                    leaf session-handle {
                      type uint32;
                      description
                        "MLDP neighbor session handle";
                    }
    
                    leaf upstream-count {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "MLDP neighbor Upstream LSP count";
                    }
    
                    leaf branch-count {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "MLDP neighbor branch count";
                    }
    
                    leaf graceful-restart-enabled {
                      type boolean;
                      description
                        "Graceful restart enabled";
                    }
    
                    leaf graceful-restart-active {
                      type boolean;
                      description
                        "LDP is in Graceful restart mode";
                    }
    
                    leaf graceful-restart-instance {
                      type uint32;
                      description
                        "Graceful restart instance";
                    }
    
                    leaf graceful-restart-reconnect-time {
                      type uint32;
                      description
                        "GR reconnect time";
                    }
    
                    leaf label-map-timer {
                      type int32;
                      units "millisecond";
                      description
                        "Label Mapping timer in milli-seconds";
                    }
    
                    leaf checkpoint-stale {
                      type boolean;
                      description
                        "MLDP neighbor information via checkpoint";
                    }
    
                    leaf path-count {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "MLDP neighbor path count";
                    }
    
                    leaf adjacency-count {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type uint32;
                      description
                        "MLDP neighbor adjacency count";
                    }
    
                    leaf inbound-neighbor-policy {
                      type string {
                        length "0..256";
                      }
                      description
                        "Inbound Neighbor Policy";
                    }
    
                    leaf outbound-neighbor-policy {
                      type string {
                        length "0..256";
                      }
                      description
                        "Outbound Neighbor Policy";
                    }
    
                    leaf peer-identity-count {
                      type uint32;
                      description
                        "MLDP peer identify count";
                    }
    
                    list neighbor-path {
                      description "Path List";
                      leaf neighbor-address {
                        type inet:ipv4-address;
                        description
                          "MLDP neighbor path address";
                      }
    
                      leaf interface-name {
                        type string {
                          length "0..65";
                        }
                        description
                          "MLDP neighbor path interface";
                      }
    
                      leaf mldp-adjacency {
                        type boolean;
                        description
                          "MLDP adjacency present";
                      }
    
                      leaf checkpoint-stale {
                        type boolean;
                        description
                          "MLDP neighbor path info via checkpoint";
                      }
    
                      leaf disabled {
                        type uint32;
                        description
                          "MLDP neighbor path is disabled";
                      }
                    }  // list neighbor-path
    
                    list neighbor-adjacency {
                      description
                        "Adjacency List";
                      leaf address {
                        type inet:ipv4-address;
                        description
                          "MLDP neighbor adjacency address";
                      }
    
                      leaf interface-name {
                        type string {
                          length "0..65";
                        }
                        description
                          "MLDP neighbor adjacency interface";
                      }
    
                      leaf checkpoint-stale {
                        type boolean;
                        description
                          "MLDP neighbor adj info via checkpoint";
                      }
    
                      leaf graceful-restart-stale {
                        type boolean;
                        description
                          "MLDP neighbor adj stale due to GR";
                      }
    
                      leaf confict-ignore {
                        type boolean;
                        description
                          "Ignore this adjacency due to conflict";
                      }
                    }  // list neighbor-adjacency
    
                    list peer-identity {
                      description
                        "Identity List";
                      leaf address {
                        type inet:ipv4-address;
                        description
                          "MLDP neighbor identity address";
                      }
                    }  // list peer-identity
                  }  // list neighbor
                }  // container neighbors
              }  // list vrf
            }  // container vrfs
    
            container default-context {
              description
                "Default context specific operational data";
              container neighbor-addresses {
                description
                  "MLDP Neighbors Addresses";
                list neighbor-address {
                  key "address";
                  description
                    "Neighbor Address Information";
                  leaf address {
                    type inet:ipv4-address-no-zone;
                    description
                      "The Neighbor IP address";
                  }
    
                  leaf address-xr {
                    type inet:ipv4-address;
                    description
                      "MLDP neighbor address";
                  }
    
                  list identity {
                    description "Identity List";
                    leaf identity-string {
                      type string {
                        length "0..32";
                      }
                      description
                        "MLDP Identity";
                    }
                  }  // list identity
                }  // list neighbor-address
              }  // container neighbor-addresses
    
              container databases {
                description "MLDP Database";
                list database {
                  key "lsp-type root-address opaque-type opaque-value-string";
                  description
                    "MLDP Database Information";
                  leaf lsp-type {
                    type Lsp;
                    description "LSP Type";
                  }
    
                  leaf root-address {
                    type inet:ipv4-address-no-zone;
                    description "Root address";
                  }
    
                  leaf opaque-type {
                    type Opaque;
                    description "Opaque Type";
                  }
    
                  leaf opaque-value-string {
                    type xr:Cisco-ios-xr-string {
                      length "1..255";
                    }
                    description "OpaqueValue";
                  }
    
                  leaf lsm-id-xr {
                    type uint32;
                    description "LSM ID";
                  }
    
                  leaf vrf-name {
                    type string {
                      length "0..256";
                    }
                    description "VRF name";
                  }
    
                  leaf up-time {
                    type uint32;
                    units "millisecond";
                    description
                      "Uptime in milli-seconds";
                  }
    
                  leaf tree-type {
                    type uint32;
                    description "Tree Type";
                  }
    
                  leaf root-address-xr {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type inet:ipv4-address;
                    description "Root address";
                  }
    
                  leaf we-are-root {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "We are the root";
                  }
    
                  leaf fec-opaque-length {
                    type uint32;
                    description
                      "FEC opaque length";
                  }
    
                  leaf opaque-decoded-string {
                    type string {
                      length "0..255";
                    }
                    description
                      "Opaque value decoded string";
                  }
    
                  leaf fec-value-length {
                    type uint32;
                    description
                      "FEC Value length";
                  }
    
                  leaf root-node-redundency-lsm-id {
                    type uint32;
                    description "RNR LSM-ID";
                  }
    
                  leaf root-node-redundency-active {
                    type boolean;
                    description "RNR Active";
                  }
    
                  leaf root-node-redundency-is-primary {
                    type boolean;
                    description
                      "RNR Primary is this entry";
                  }
    
                  leaf root-node-redundency-lsm-id-primary {
                    type uint32;
                    description
                      "RNR Primary LSM ID";
                  }
    
                  leaf root-node-redundency-root-address {
                    type inet:ipv4-address;
                    description
                      "RNR Root node address";
                  }
    
                  leaf root-node-redundency-candidate-string {
                    type string {
                      length "0..80";
                    }
                    description
                      "RNR candidate list";
                  }
    
                  leaf is-ldp-branch {
                    type boolean;
                    description "LDP Branch";
                  }
    
                  leaf is-local-branch {
                    type boolean;
                    description "Local Branch";
                  }
    
                  leaf is-local-interface {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "Local Interface";
                  }
    
                  leaf role-egress {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description "Role Egress";
                  }
    
                  leaf forwarding-peek {
                    type boolean;
                    description
                      "Peek is enabled";
                  }
    
                  leaf make-before-break-enabled {
                    type boolean;
                    description
                      "MBB feature is enabled";
                  }
    
                  leaf mo-frr-enabled {
                    type boolean;
                    description
                      "MoFRR feature is enabled";
                  }
    
                  leaf recursive-fec-enabled {
                    type boolean;
                    description
                      "Recursive FEC is enabled";
                  }
    
                  leaf trace-enabled {
                    type boolean;
                    description
                      "Trace filter is enabled";
                  }
    
                  leaf forward-recursive {
                    type boolean;
                    description
                      "Recursive Forwarding is enabled";
                  }
    
                  leaf peer-change-delay {
                    type int32;
                    units "millisecond";
                    description
                      "Neighbor change delay in milli-seconds";
                  }
    
                  leaf encode-branch-id {
                    type uint32;
                    description
                      "Recursive FEC Encode LSM ID";
                  }
    
                  leaf decode-branch-id {
                    type uint32;
                    description
                      "Recursive FEC Decode LSM ID";
                  }
    
                  leaf upstream-neigbbor-count {
                    type uint32;
                    description
                      "Upstream MLDP neighbor count";
                  }
    
                  leaf downstream-branch-count {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "Downstream branch count";
                  }
    
                  list upstream-neighbor {
                    description
                      "Upstream neighbor List";
                    leaf lsm-id {
                      type uint32;
                      description "LSM ID";
                    }
    
                    leaf mldp-peer {
                      type string {
                        length "0..32";
                      }
                      description
                        "MLDP Neighbor Identity";
                    }
    
                    leaf mpls-local-label {
                      type uint32;
                      description "Local Label";
                    }
    
                    leaf mpls-label-upstream {
                      type uint32;
                      description "Remote Label";
                    }
    
                    leaf active {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "Neighbor is active";
                    }
    
                    leaf delete-pending {
                      type boolean;
                      description
                        "Neighbor is delete pending";
                    }
    
                    leaf checkpoint-stale {
                      type boolean;
                      description
                        "MLDP neighbor information via checkpoint";
                    }
    
                    leaf make-before-break-ack {
                      type boolean;
                      description
                        "Make-before-break ack received";
                    }
    
                    leaf make-before-break-ack-pending {
                      type boolean;
                      description
                        "Make-before-break ack pending";
                    }
    
                    leaf mfi-duplicate-ignore {
                      type boolean;
                      description
                        "MFI duplicate ignore by forwarding";
                    }
    
                    leaf peer-change-delay {
                      type int32;
                      units "millisecond";
                      description
                        "Neighbor change delay in milli-seconds";
                    }
    
                    leaf delete-delay {
                      type int32;
                      units "millisecond";
                      description
                        "Upstream neighbor delete delay in milli-seconds";
                    }
    
                    leaf interface-name {
                      type string {
                        length "0..65";
                      }
                      description
                        "Root Interface";
                    }
    
                    leaf root-address-next-hop {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type inet:ipv4-address;
                      description
                        "Root next-hop address";
                    }
    
                    leaf up-time {
                      type uint32;
                      units "millisecond";
                      description
                        "Neighbor uptime in milli-seconds";
                    }
    
                    leaf state-change-time {
                      type uint32;
                      units "millisecond";
                      description
                        "State change time in milli-seconds";
                    }
    
                    leaf csi-accepting {
                      type boolean;
                      description
                        "If ACEL is CSI accepting";
                    }
                  }  // list upstream-neighbor
    
                  list branch {
                    description "Branch List";
                    leaf lsm-id {
                      type uint32;
                      description "LSM ID";
                    }
    
                    leaf branch-owner {
                      type string {
                        length "0..32";
                      }
                      description
                        "Branch owner string";
                    }
    
                    leaf up-time {
                      type uint32;
                      units "millisecond";
                      description
                        "Branch uptime in milli-seconds";
                    }
    
                    leaf graceful-restart-stale {
                      type boolean;
                      description
                        "Branch has been marked stale by graceful restart";
                    }
    
                    leaf graceful-restart-instance {
                      type uint32;
                      description
                        "Branch graceful restart instance";
                    }
    
                    leaf mpls-label {
                      type uint32;
                      description
                        "Branch Remote label";
                    }
    
                    leaf mpls-local-label-upstream {
                      type uint32;
                      description
                        "Branch Local label";
                    }
    
                    leaf head-lsm-id {
                      type uint32;
                      description "Head LSM ID";
                    }
    
                    leaf recursive-owner-id {
                      type uint32;
                      description
                        "Recursive Branch ownerLSM ID";
                    }
    
                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "Branch next-hop address";
                    }
    
                    leaf interface-name {
                      type string {
                        length "0..65";
                      }
                      description
                        "Branch next-hop interface name";
                    }
    
                    leaf interface-down {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "Interface is down";
                    }
    
                    leaf egress-interface-name {
                      type string {
                        length "0..64";
                      }
                      description
                        "Egress interface name";
                    }
    
                    leaf vrf-name {
                      type string {
                        length "0..33";
                      }
                      description "VRF name";
                    }
    
                    leaf owner-id {
                      type uint32;
                      description
                        "Branch owner ID";
                    }
    
                    leaf egress {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "Branch is Egress";
                    }
    
                    leaf mfi-peek {
                      type boolean;
                      description
                        "Branch Peek is enabled";
                    }
    
                    leaf ingress {
                      xr:event-telemetry "Subscribe Telemetry Event";
                      type boolean;
                      description
                        "Branch is Ingress";
                    }
    
                    leaf ppmp {
                      type boolean;
                      description
                        "Branch PPMP is enabled";
                    }
    
                    leaf drop {
                      type boolean;
                      description
                        "Branch DROP is set";
                    }
    
                    leaf ordered-mode {
                      type boolean;
                      description
                        "Branch is enabled for ordered mode";
                    }
    
                    leaf mame-before-break-request {
                      type boolean;
                      description
                        "MBB request received on this branch";
                    }
    
                    leaf application-stale {
                      type boolean;
                      description
                        "Branch marked stale by application";
                    }
    
                    leaf mfi-duplicate-ignore {
                      type boolean;
                      description
                        "MFI duplicate ignore by forwarding";
                    }
    
                    leaf rpf-id {
                      type uint32;
                      description
                        "Branch RPF ID";
                    }
    
                    leaf ldp-message-id {
                      type uint32;
                      description
                        "Branch LDP message ID";
                    }
    
                    leaf rd-name {
                      type string {
                        length "0..65";
                      }
                      description
                        "Recursive RD name";
                    }
                  }  // list branch
                }  // list database
              }  // container databases
    
              container root-addresses {
                description "MLDP Root Table";
                list root-address {
                  key "root-address";
                  description
                    "MLDP Root Information";
                  leaf root-address {
                    type inet:ipv4-address-no-zone;
                    description "Root address";
                  }
    
                  leaf address {
                    type inet:ipv4-address;
                    description "Root address";
                  }
    
                  leaf we-are-root {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "We are the root";
                  }
    
                  leaf checkpoint-stale {
                    type boolean;
                    description
                      "MLDP root information via checkpoint";
                  }
    
                  leaf via-bgp {
                    type boolean;
                    description
                      "Route learned via BGP";
                  }
    
                  leaf via-static {
                    type boolean;
                    description
                      "Route learned via Static";
                  }
    
                  leaf metric {
                    type uint32;
                    description "Metric";
                  }
    
                  leaf distance {
                    type uint32;
                    description "Distance";
                  }
    
                  leaf interface-name {
                    type string {
                      length "0..65";
                    }
                    description "Root Interface";
                  }
    
                  leaf fec-count {
                    type uint32;
                    description
                      "LSP's linked to this root";
                  }
    
                  leaf recursice-fec-count {
                    type uint32;
                    description
                      "Recursive LSP's linked to this root";
                  }
    
                  leaf path-count {
                    type uint32;
                    description
                      "Paths to reach this root";
                  }
    
                  list root-path {
                    description "Root path list";
                    leaf root-address {
                      type inet:ipv4-address;
                      description "Root address";
                    }
    
                    leaf mldp-identity-string {
                      type string {
                        length "0..32";
                      }
                      description
                        "MLDP neighbor identity";
                    }
    
                    leaf checkpoint-stale {
                      type boolean;
                      description
                        "MLDP root path information via checkpoint";
                    }
    
                    leaf php-next-hop-address {
                      type inet:ipv4-address;
                      description
                        "Penultimate next-hop";
                    }
                  }  // list root-path
    
                  list root-ipmsi {
                    description
                      "Root I-PMSI list";
                    leaf next-hop-address-ipv4 {
                      type inet:ipv4-address;
                      description
                        "IPMSI IPv4 next-hop address";
                    }
    
                    leaf next-hop-address-ipv6 {
                      type inet:ipv4-address;
                      description
                        "IPMSI IPv6 next-hop address";
                    }
    
                    leaf rd-name {
                      type string {
                        length "0..65";
                      }
                      description "RD name";
                    }
                  }  // list root-ipmsi
                }  // list root-address
              }  // container root-addresses
    
              container context {
                description "MLDP Context";
                leaf vrf-name {
                  type string {
                    length "0..33";
                  }
                  description "VRF name";
                }
    
                leaf active-table-name {
                  type string {
                    length "0..32";
                  }
                  description
                    "Active RIB Table Name for this VRF";
                }
    
                leaf lsp-count {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type uint32;
                  description
                    "Number of P2MP/MP2MP LSPs in the vrf";
                }
    
                leaf peer-count {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type uint32;
                  description
                    "Number of mLDP neighbors in the vrf";
                }
    
                leaf mu-rib-enabled {
                  type boolean;
                  description "MuRIB is enabled";
                }
    
                leaf multi-path-upstream-enabled {
                  type boolean;
                  description
                    "Multi-path Upstream is enabled";
                }
    
                leaf multi-path-downstream-enabled {
                  type boolean;
                  description
                    "Multi-path Downstream is enabled";
                }
    
                leaf make-before-break-delay {
                  xr:event-telemetry "Subscribe Telemetry Event";
                  type uint32;
                  units "millisecond";
                  description
                    "Make-before-break delay in milli-seconds";
                }
    
                leaf mldp-table-count {
                  type uint32;
                  description
                    "Number of mLDP tables";
                }
    
                list mldp-table {
                  description
                    "List of mLDP tables";
                  leaf table-name {
                    type string {
                      length "0..32";
                    }
                    description "Table name";
                  }
    
                  leaf rib-converged {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "RIB table converged";
                  }
    
                  leaf rib-table-id {
                    type uint32;
                    description "RIB Table ID";
                  }
                }  // list mldp-table
              }  // container context
    
              container neighbors {
                description "MLDP Neighbors";
                list neighbor {
                  key "address";
                  description
                    "Neighbor Information";
                  leaf address {
                    type inet:ipv4-address-no-zone;
                    description
                      "The Neighbor IP address";
                  }
    
                  leaf identity-string {
                    type string {
                      length "0..32";
                    }
                    description
                      "MLDP Identity string";
                  }
    
                  leaf capabilities {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "MLDP neighbor capabilities";
                  }
    
                  leaf up-time {
                    type uint32;
                    units "millisecond";
                    description
                      "MLDP neighbor uptime in milli-seconds";
                  }
    
                  leaf down {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type boolean;
                    description
                      "MLDP neighbor is marked as down";
                  }
    
                  leaf target-adjacency {
                    type boolean;
                    description
                      "MLDP neighbor is targetted";
                  }
    
                  leaf session-handle {
                    type uint32;
                    description
                      "MLDP neighbor session handle";
                  }
    
                  leaf upstream-count {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "MLDP neighbor Upstream LSP count";
                  }
    
                  leaf branch-count {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "MLDP neighbor branch count";
                  }
    
                  leaf graceful-restart-enabled {
                    type boolean;
                    description
                      "Graceful restart enabled";
                  }
    
                  leaf graceful-restart-active {
                    type boolean;
                    description
                      "LDP is in Graceful restart mode";
                  }
    
                  leaf graceful-restart-instance {
                    type uint32;
                    description
                      "Graceful restart instance";
                  }
    
                  leaf graceful-restart-reconnect-time {
                    type uint32;
                    description
                      "GR reconnect time";
                  }
    
                  leaf label-map-timer {
                    type int32;
                    units "millisecond";
                    description
                      "Label Mapping timer in milli-seconds";
                  }
    
                  leaf checkpoint-stale {
                    type boolean;
                    description
                      "MLDP neighbor information via checkpoint";
                  }
    
                  leaf path-count {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "MLDP neighbor path count";
                  }
    
                  leaf adjacency-count {
                    xr:event-telemetry "Subscribe Telemetry Event";
                    type uint32;
                    description
                      "MLDP neighbor adjacency count";
                  }
    
                  leaf inbound-neighbor-policy {
                    type string {
                      length "0..256";
                    }
                    description
                      "Inbound Neighbor Policy";
                  }
    
                  leaf outbound-neighbor-policy {
                    type string {
                      length "0..256";
                    }
                    description
                      "Outbound Neighbor Policy";
                  }
    
                  leaf peer-identity-count {
                    type uint32;
                    description
                      "MLDP peer identify count";
                  }
    
                  list neighbor-path {
                    description "Path List";
                    leaf neighbor-address {
                      type inet:ipv4-address;
                      description
                        "MLDP neighbor path address";
                    }
    
                    leaf interface-name {
                      type string {
                        length "0..65";
                      }
                      description
                        "MLDP neighbor path interface";
                    }
    
                    leaf mldp-adjacency {
                      type boolean;
                      description
                        "MLDP adjacency present";
                    }
    
                    leaf checkpoint-stale {
                      type boolean;
                      description
                        "MLDP neighbor path info via checkpoint";
                    }
    
                    leaf disabled {
                      type uint32;
                      description
                        "MLDP neighbor path is disabled";
                    }
                  }  // list neighbor-path
    
                  list neighbor-adjacency {
                    description "Adjacency List";
                    leaf address {
                      type inet:ipv4-address;
                      description
                        "MLDP neighbor adjacency address";
                    }
    
                    leaf interface-name {
                      type string {
                        length "0..65";
                      }
                      description
                        "MLDP neighbor adjacency interface";
                    }
    
                    leaf checkpoint-stale {
                      type boolean;
                      description
                        "MLDP neighbor adj info via checkpoint";
                    }
    
                    leaf graceful-restart-stale {
                      type boolean;
                      description
                        "MLDP neighbor adj stale due to GR";
                    }
    
                    leaf confict-ignore {
                      type boolean;
                      description
                        "Ignore this adjacency due to conflict";
                    }
                  }  // list neighbor-adjacency
    
                  list peer-identity {
                    description "Identity List";
                    leaf address {
                      type inet:ipv4-address;
                      description
                        "MLDP neighbor identity address";
                    }
                  }  // list peer-identity
                }  // list neighbor
              }  // container neighbors
            }  // container default-context
          }  // container standby
        }  // container mpls-mldp
      }  // module Cisco-IOS-XR-mpls-ldp-mldp-oper
    

© 2023 YumaWorks, Inc. All rights reserved.