submodule Cisco-IOS-XR-mpls-ldp-oper-sub1 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-mpls-ldp-oper {
        prefix Cisco-IOS-XR-mpls-ldp-oper;
    }

    import ietf-inet-types {
      prefix inet;
    }
    import Cisco-IOS-XR-types {
      prefix xr;
    }
    import cisco-semver {
      prefix semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service
     
     Postal: 170 West Tasman Drive
     San Jose, CA 95134
     
     Tel: +1 800 553-NETS
     
     E-mail: cs-yang@cisco.com";

    description
      "This submodule contains a collection of YANG definitions
     for Cisco IOS-XR mpls-ldp package operational data.
     
     Copyright (c) 2013-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-04-06" {
      description
        "Added BSID data in LDP forwarding
       2021-03-10
         Added adj_grp count leaf to ldp summary
       2020-08-14
         Added ELC parameter.";
    }

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

    revision "2017-09-07" {
      description
        "Fixed type translation error.";
    }

    revision "2017-05-01" {
      description
        "Fixing backward compatibility error in module.";
    }

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

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

    typedef Mgmt-ldp-nbr-bgp-advt-state {
      type enumeration {
        enum "not-applicable" {
          value 0;
          description "Not applicable";
        }
        enum "permit" {
          value 1;
          description
            "Advertisement permitted";
        }
        enum "deny" {
          value 2;
          description "Advertisement denied";
        }
      }
      description
        "MPLS LDP Neighbor BGP Label Advertisement State
       Type";
    }

    typedef Mgmt-ldp-nsr-peer-ldp-sync-nack-rsn {
      type enumeration {
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-none" {
          value 0;
          description
            "mgmt ldp nsr peer ldp sync nack rsn none";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-tbl-id-mismatch" {
          value 1;
          description
            "mgmt ldp nsr peer ldp sync nack rsn tbl id
           mismatch";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-pp-exists" {
          value 2;
          description
            "mgmt ldp nsr peer ldp sync nack rsn pp exists";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-missing-elem" {
          value 3;
          description
            "mgmt ldp nsr peer ldp sync nack rsn missing
           elem";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-no-p-end-sock" {
          value 4;
          description
            "mgmt ldp nsr peer ldp sync nack rsn no p end
           sock";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-p-end-sock-not-synced" {
          value 5;
          description
            "mgmt ldp nsr peer ldp sync nack rsn p end sock
           not synced";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-adj-add" {
          value 6;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err adj add";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-dhcb-add" {
          value 7;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err dhcb
           add";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-enomem" {
          value 8;
          description
            "mgmt ldp nsr peer ldp sync nack rsn enomem";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-tp-create" {
          value 9;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err tp
           create";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-pp-create" {
          value 10;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err pp
           create";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-addr-bind" {
          value 11;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err addr
           bind";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-rx-bad-pie" {
          value 12;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err rx bad
           pie";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-rx-notif" {
          value 13;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err rx
           notif";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-rx-unexp-open" {
          value 14;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err rx
           unexp open";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-unexp-peer-down" {
          value 15;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err unexp
           peer down";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-app-not-found" {
          value 16;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err app not
           found";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-app-invalid" {
          value 17;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err app
           invalid";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-adj-grp-not-found" {
          value 18;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err adj grp
           not found";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-invalid-elem" {
          value 19;
          description
            "mgmt ldp nsr peer ldp sync nack rsn invalid
           elem";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-app-data-invalid" {
          value 20;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err app
           data invalid";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-invalid-per-idx" {
          value 21;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err invalid
           per idx";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-pfx-not-found" {
          value 22;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err pfx not
           found";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-bm-size-invalid" {
          value 23;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err bm size
           invalid";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-adv-bm-clear" {
          value 24;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err adv bm
           clear";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-err-tcp-struct-create" {
          value 25;
          description
            "mgmt ldp nsr peer ldp sync nack rsn err tcp
           struct create";
        }
        enum
          "mgmt-ldp-nsr-peer-ldp-sync-nack-rsn-no-ctx" {
          value 26;
          description
            "mgmt ldp nsr peer ldp sync nack rsn no ctx";
        }
      }
      description
        "Mgmt ldp nsr peer ldp sync nack rsn";
    }

    typedef Mgmt-ldp-nsr-peer-sync-err {
      type enumeration {
        enum
          "mgmt-ldp-nsr-peer-sync-err-none" {
          value 0;
          description
            "mgmt ldp nsr peer sync err none";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-err-ldp-sync-nack" {
          value 1;
          description
            "mgmt ldp nsr peer sync err ldp sync nack";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-err-sync-prep" {
          value 2;
          description
            "mgmt ldp nsr peer sync err sync prep";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-err-tcp-peer" {
          value 3;
          description
            "mgmt ldp nsr peer sync err tcp peer";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-err-tcp-gbl" {
          value 4;
          description
            "mgmt ldp nsr peer sync err tcp gbl";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-err-ldp-peer" {
          value 5;
          description
            "mgmt ldp nsr peer sync err ldp peer";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-err-ldp-gbl" {
          value 6;
          description
            "mgmt ldp nsr peer sync err ldp gbl";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-err-app-fail" {
          value 7;
          description
            "mgmt ldp nsr peer sync err app fail";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-err-sync-tcp-phase1" {
          value 8;
          description
            "mgmt ldp nsr peer sync err sync tcp phase1";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-err-sync-tcp-phase2" {
          value 9;
          description
            "mgmt ldp nsr peer sync err sync tcp phase2";
        }
      }
      description
        "Mgmt ldp nsr peer sync err";
    }

    typedef Mgmt-ldp-nsr-peer-sync-state {
      type enumeration {
        enum
          "mgmt-ldp-nsr-peer-sync-st-none" {
          value 0;
          description
            "mgmt ldp nsr peer sync st none";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-st-wait" {
          value 1;
          description
            "mgmt ldp nsr peer sync st wait";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-st-ready" {
          value 2;
          description
            "mgmt ldp nsr peer sync st ready";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-st-prep" {
          value 3;
          description
            "mgmt ldp nsr peer sync st prep";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-st-app-wait" {
          value 4;
          description
            "mgmt ldp nsr peer sync st app wait";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-st-oper" {
          value 5;
          description
            "mgmt ldp nsr peer sync st oper";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-st-tcp-phase1" {
          value 6;
          description
            "mgmt ldp nsr peer sync st tcp phase1";
        }
        enum
          "mgmt-ldp-nsr-peer-sync-st-tcp-phase2" {
          value 7;
          description
            "mgmt ldp nsr peer sync st tcp phase2";
        }
      }
      description
        "Mgmt ldp nsr peer sync state";
    }

    typedef Ldp-adj-union-discrim {
      type enumeration {
        enum "link-hello" {
          value 0;
          description "Link hello";
        }
        enum "targeted-hello" {
          value 1;
          description "Targeted hello";
        }
      }
      description "MPLS LDP Hello Type";
    }

    typedef Show-nsr-state {
      type enumeration {
        enum "nsr-ready" {
          value 0;
          description "NSR ready";
        }
        enum "nsr-not-ready" {
          value 1;
          description "NSR not ready";
        }
        enum "nsr-na" {
          value 2;
          description "NSR not applicable";
        }
      }
      description "NSR State Type";
    }

    typedef Ldp-route-path-lbl-owner {
      type enumeration {
        enum "ip-path-lbl-owner-none" {
          value 0;
          description
            "No label and no owner";
        }
        enum "ip-path-lbl-owner-ldp" {
          value 1;
          description
            "Path outgoing label owned by LDP";
        }
        enum "ip-path-lbl-owner-bgp" {
          value 2;
          description
            "Path outgoing label owned by BGP";
        }
      }
      description "Route path label owner";
    }

    typedef Label-value {
      type enumeration {
        enum "mpls-label" {
          value 0;
          description "MPLS Label";
        }
        enum "un-labelled" {
          value 1;
          description "Unlabelled";
        }
        enum "unknown" {
          value 2;
          description "Unknown label";
        }
      }
      description "Label Value Type";
    }

    typedef Ldp-fwd-unlbl-rsn {
      type enumeration {
        enum "ldp-fwd-labelled" {
          value 0;
          description "ldp fwd labelled";
        }
        enum "ldp-fwd-un-labelled-vrf-down" {
          value 1;
          description
            "ldp fwd un labelled vrf down";
        }
        enum "ldp-fwd-un-labelled-no-nh" {
          value 2;
          description
            "ldp fwd un labelled no nh";
        }
        enum
          "ldp-fwd-un-labelled-recursive-path" {
          value 3;
          description
            "ldp fwd un labelled recursive path";
        }
        enum
          "ldp-fwd-un-labelled-intf-not-ldp" {
          value 4;
          description
            "ldp fwd un labelled intf not ldp";
        }
        enum "ldp-fwd-un-labelled-no-rmt" {
          value 5;
          description
            "ldp fwd un labelled no rmt";
        }
        enum
          "ldp-fwd-un-labelled-no-ldp-adj" {
          value 6;
          description
            "ldp fwd un labelled no ldp adj";
        }
        enum
          "ldp-fwd-un-labelled-no-session" {
          value 7;
          description
            "ldp fwd un labelled no session";
        }
        enum "ldp-fwd-un-labelled-unknown" {
          value 8;
          description
            "ldp fwd un labelled unknown";
        }
      }
      description "Ldp fwd unlbl rsn";
    }

    typedef Ldp-route-path-flags {
      type enumeration {
        enum "ip-path-no-flag" {
          value 0;
          description
            "A primary path with no special flag/attribute";
        }
        enum "ip-path-protected" {
          value 1;
          description
            "A primary path with LFA FRR protection";
        }
        enum "ip-path-backup" {
          value 2;
          description
            "A non-primary local LFA FRR (pure) backup path";
        }
        enum "ip-path-backup-remote" {
          value 3;
          description
            "A non-primary remote LFA FRR (pure) backup path";
        }
        enum "ip-path-bgp-backup" {
          value 4;
          description
            "A non-primary BGP backup path";
        }
      }
      description "Route path flags";
    }

    typedef Dhcb-state {
      type enumeration {
        enum "none" {
          value 0;
          description "None";
        }
        enum "dhcb-active" {
          value 1;
          description "Active";
        }
        enum "dhcb-passive" {
          value 2;
          description "Passive";
        }
        enum "dhcb-active-passive" {
          value 3;
          description "Active and Passive";
        }
      }
      description "DHCB State Type";
    }

    typedef Ldp-igp-sync-down-reason {
      type enumeration {
        enum
          "igp-sync-down-reason-not-applicable" {
          value 0;
          description "Not Applicable";
        }
        enum "no-hello-adjacency" {
          value 1;
          description "No hello adjacency";
        }
        enum "no-peer-session" {
          value 2;
          description "No peer session";
        }
        enum
          "initial-update-to-peer-not-done" {
          value 3;
          description
            "Initial update to peer not done yet";
        }
        enum
          "initial-update-from-peer-not-received" {
          value 4;
          description
            "Initial update from peer not received yet";
        }
        enum "internal-reason" {
          value 5;
          description "Internal reason";
        }
      }
      description
        "Reason IGP Sync Not Achieved";
    }

    typedef String-td2 {
      type string;
      description "String td2";
    }

    typedef Ldp-igp-sync-state {
      type enumeration {
        enum "isync-ready" {
          value 0;
          description "Acheived";
        }
        enum "isync-not-ready" {
          value 1;
          description "Not acheived";
        }
        enum "isync-deferred" {
          value 2;
          description
            "Deferred due to interface delay or global
           restart delay";
        }
      }
      description "IGP Sync State";
    }

    typedef Local-label-state {
      type enumeration {
        enum "local-label-state-none" {
          value 1;
          description "None";
        }
        enum "local-label-state-assigned" {
          value 2;
          description "Assigned";
        }
        enum "local-label-state-withdrawn" {
          value 3;
          description "Withdrawn";
        }
      }
      description
        "MPLS LDP Local Label State Type";
    }

    typedef Ldp-af {
      type enumeration {
        enum "ldp-show-af-none" {
          value 0;
          description "No Address Family";
        }
        enum "ldp-show-af-ipv4" {
          value 1;
          description "IPv4 AFI";
        }
        enum "ldp-show-af-ipv6" {
          value 2;
          description "IPv6 AFI";
        }
        enum "ldp-show-af-ipv4-ipv6" {
          value 3;
          description "Both IPv4/IPv6 AFIs";
        }
      }
      description "Ldp af";
    }

    typedef Ldp-in6-addr {
      type inet:ipv6-address;
      description "Ldp in6 addr";
    }

    typedef Ldp-in-addr {
      type inet:ipv4-address;
      description "Ldp in addr";
    }

    typedef Ldp-af-id {
      type enumeration {
        enum "ldp-af-id-none" {
          value 0;
          description "No Address Family";
        }
        enum "ldp-af-id-ipv4" {
          value 2;
          description "IPv4 AFI";
        }
        enum "ldp-af-id-ipv6" {
          value 10;
          description "IPv6 AFI";
        }
      }
      description "Ldp af id";
    }

    grouping LDP-SUMMARY {
      description
        "MPLS LDP Summarized Information";
      container common {
        description
          "Common Summary information";
        uses LDP-SUMMARY-COMMON;
      }  // container common

      leaf number-of-vrf {
        type uint32;
        description
          "Number of configured VRFs (including default)";
      }

      leaf number-of-vrf-oper {
        type uint32;
        description
          "Number of configured operational VRFs (including
         default)";
      }

      leaf number-of-interfaces {
        type uint32;
        description
          "Number of known interfaces";
      }

      leaf number-of-fwd-ref-interfaces {
        type uint32;
        description
          "Number of Forward Referenc interfaces";
      }

      leaf number-of-autocfg-interfaces {
        type uint32;
        description
          "Number of auto-configured interfaces";
      }

      leaf is-bound-with-sysdb {
        type boolean;
        description
          "Bound status with sysdb";
      }

      leaf is-registered-with-sysdb {
        type boolean;
        description
          "Registration status with Sysdb";
      }

      leaf is-bound-with-rsi {
        type boolean;
        description "Bound status with rsi";
      }

      leaf is-bound-with-interface-manager {
        type boolean;
        description
          "Bound status with Interface Manager";
      }

      leaf is-registered-with-interface-manager {
        type boolean;
        description
          "Registration status with Interface Manager";
      }

      leaf is-bound-with-ip-arm {
        type boolean;
        description
          "Bound status with IP Arm";
      }

      leaf is-bound-with-lsd {
        type boolean;
        description "Bound status with LSD";
      }

      leaf is-registered-with-lsd {
        type boolean;
        description
          "Registration status with LSD";
      }

      leaf is-bound-with-ipv4-rib {
        type boolean;
        description
          "Bound status with IPv4 RIB";
      }

      leaf is-registered-with-ipv4-rib {
        type boolean;
        description
          "Registration status with IPv4 RIB";
      }

      leaf number-of-ipv4rib-tables {
        type uint32;
        description
          "Total number of ipv4 RIB tables";
      }

      leaf number-of-registered-ipv4rib-tables {
        type uint32;
        description
          "Number of ipv4 RIB tables registered";
      }

      leaf is-bound-with-ipv6-rib {
        type boolean;
        description
          "Bound status with IPv6 RIB";
      }

      leaf is-registered-with-ipv6-rib {
        type boolean;
        description
          "Registration status with IPv6 RIB";
      }

      leaf number-of-ipv6rib-tables {
        type uint32;
        description
          "Total number of ipv6 RIB tables";
      }

      leaf number-of-registered-ipv6rib-tables {
        type uint32;
        description
          "Number of ipv6 RIB tables registered";
      }

      leaf is-bound-with-atom {
        type boolean;
        description
          "Bound status with L2VPN ATOM";
      }

      leaf is-bound-with-nsr-mate {
        type boolean;
        description
          "Bound status with NSR Mate";
      }

      leaf is-nsr-configured {
        type boolean;
        description "NSR configured";
      }

      leaf is-mldp-registered {
        type boolean;
        description
          "mLDP registration status";
      }
    }  // grouping LDP-SUMMARY

    grouping LDP-MSG-COUNTERS {
      description
        "MPLS LDP Session Message Counters Information";
      leaf total-count {
        type uint32;
        description "Total message count";
      }

      leaf init-count {
        type uint32;
        description "Init message count";
      }

      leaf address-count {
        type uint32;
        description "Address message count";
      }

      leaf address-withdraw-count {
        type uint32;
        description "Address withdraw count";
      }

      leaf label-map-count {
        type uint32;
        description "Label map count";
      }

      leaf label-withdraw-count {
        type uint32;
        description "Label withdraw count";
      }

      leaf label-release-count {
        type uint32;
        description "Label release count";
      }

      leaf label-request-count {
        type uint32;
        description "Label request count";
      }

      leaf label-abort-request-count {
        type uint32;
        description
          "Label abort request count";
      }

      leaf notification-count {
        type uint32;
        description "Notification count";
      }

      leaf keep-alive-count {
        type uint32;
        description "Keepalive count";
      }

      leaf iccp-rg-conn-count {
        type uint32;
        description "ICCP RG Connect count";
      }

      leaf iccp-rg-disconn-count {
        type uint32;
        description
          "ICCP RG Disconnect count";
      }

      leaf iccp-rg-notif-count {
        type uint32;
        description "ICCP RG Notif count";
      }

      leaf iccp-rg-app-data-count {
        type uint32;
        description "ICCP RG App Data count";
      }
    }  // grouping LDP-MSG-COUNTERS

    grouping LDP-STATS-INFO {
      description
        "MPLS LDP Statistics Information";
      container message-out {
        description "Message out count";
        uses LDP-MSG-COUNTERS;
      }  // container message-out

      container message-in {
        description "Message in count";
        uses LDP-MSG-COUNTERS;
      }  // container message-in

      leaf iccp-enabled {
        type boolean;
        description
          "Is session ICCP enabled?";
      }
    }  // grouping LDP-STATS-INFO

    grouping LDP-NBR-CLIENTS-INFO {
      description
        "MPLS LDP Session client Information";
      leaf name {
        type string;
        description "Client's name";
      }
    }  // grouping LDP-NBR-CLIENTS-INFO

    grouping LDP-NBR-DETAILED-INFO {
      description
        "MPLS LDP Neighbor Detailed Information";
      container capabilities {
        description
          "Capabilities sent to and received from neighbor";
        uses LDP-NBR-CAP-INFO;
      }  // container capabilities

      leaf peer-holdtime {
        type uint32;
        units "second";
        description
          "Session holdtime value in seconds from the peer";
      }

      leaf keep-alive-interval {
        type uint32;
        units "second";
        description
          "Session keepalive interval in seconds";
      }

      leaf peer-state {
        type string {
          length "0..80";
        }
        description "Peer state";
      }

      leaf has-ipv4-inbound {
        type boolean;
        description
          "IPv4 Inbound label filtering present";
      }

      leaf inbound-ipv4acl {
        type string {
          length "0..80";
        }
        description
          "IPv4 Inbound accept ACL";
      }

      leaf has-ipv6-inbound {
        type boolean;
        description
          "IPv6 Inbound label filtering present";
      }

      leaf inbound-ipv6acl {
        type string {
          length "0..80";
        }
        description
          "IPv6 Inbound accept ACL";
      }

      leaf has-ipv4-outbound {
        type boolean;
        description
          "IPv4 Outbound label filtering present";
      }

      leaf outbound-ipv4acl {
        type string {
          length "0..80";
        }
        description
          "IPv4 Outbound advertise ACL";
      }

      leaf has-ipv6-outbound {
        type boolean;
        description
          "IPv6 Outbound label filtering present";
      }

      leaf outbound-ipv6acl {
        type string {
          length "0..80";
        }
        description
          "IPv6 Outbound advertise ACL";
      }

      leaf has-sp {
        type boolean;
        description
          "Session Protection enabled";
      }

      leaf sp-state {
        type string {
          length "0..80";
        }
        description
          "Session Protection state";
      }

      leaf sp-has-acl {
        type boolean;
        description
          "Session protection ACL is present";
      }

      leaf spacl {
        type string {
          length "0..80";
        }
        description "Session Protection ACL";
      }

      leaf sp-has-duration {
        type boolean;
        description
          "Session Protection has non-default duration";
      }

      leaf sp-duration {
        type uint32;
        units "second";
        description
          "Session protection holdup time duration in
         seconds";
      }

      leaf spht-running {
        type boolean;
        description
          "Session Protection holdup timer is running";
      }

      leaf spht-remaining {
        type uint32;
        units "second";
        description
          "Session Protection holdup time remaining value
         in seconds";
      }

      leaf nsr-sync-state {
        type Mgmt-ldp-nsr-peer-sync-state;
        description "NSR Sync State";
      }

      leaf nsr-last-sync-error {
        type Mgmt-ldp-nsr-peer-sync-err;
        description "Last NSR sync error";
      }

      leaf nsr-last-sync-nack-reason {
        type Mgmt-ldp-nsr-peer-ldp-sync-nack-rsn;
        description
          "Last NSR sync NACK reaston";
      }

      leaf bgp-advertisement-state {
        type Mgmt-ldp-nbr-bgp-advt-state;
        description
          "BGP labelled prefixes advertisement state";
      }

      leaf advertise-bgp-prefixes {
        type boolean;
        description
          "Is BGP labelled prefixes advertised to the
         neighbor";
      }

      list client {
        description
          "Targeted Session clients";
        uses LDP-NBR-CLIENTS-INFO;
      }  // list client

      list ipv4-duplicate-address {
        description
          "Duplicate IPv4 address bound to this peer";
        uses LDP-NBR-ADDR-INFO;
      }  // list ipv4-duplicate-address

      list ipv6-duplicate-address {
        description
          "Duplicate IPv6 address bound to this peer";
        uses LDP-NBR-ADDR-INFO;
      }  // list ipv6-duplicate-address
    }  // grouping LDP-NBR-DETAILED-INFO

    grouping TARGETED-HELLO {
      description
        "MPLS LDP Targeted Hello Information";
      container local-address {
        description "Local Address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container local-address

      container target-address {
        description "Target Address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container target-address

      leaf state {
        type Dhcb-state;
        description "State";
      }
    }  // grouping TARGETED-HELLO

    grouping LINK-HELLO {
      description
        "MPLS LDP Link Hello Information";
      leaf interface {
        type xr:Interface-name;
        description "Interface name";
      }

      leaf interface-name {
        type string;
        description "Interface name";
      }
    }  // grouping LINK-HELLO

    grouping LDP-ADJ-UNION {
      description "LDP ADJ UNION";
      container link-hello-data {
        when "../hello-type = 'link-hello'" {
          description
            "../HelloType = 'LinkHello'";
        }
        description "Link hello";
        uses LINK-HELLO;
      }  // container link-hello-data

      container target-hello-data {
        when
          "../hello-type = 'targeted-hello'" {
          description
            "../HelloType = 'TargetedHello'";
        }
        description "Target Hello";
        uses TARGETED-HELLO;
      }  // container target-hello-data

      leaf hello-type {
        type Ldp-adj-union-discrim;
        description "HelloType";
      }
    }  // grouping LDP-ADJ-UNION

    grouping LDP-NBR-ADJ-INFO {
      description
        "MPLS LDP Neighbor Adjacency Information";
      container adjacency-group {
        description "Adjacency group";
        uses LDP-ADJ-UNION;
      }  // container adjacency-group
    }  // grouping LDP-NBR-ADJ-INFO

    grouping LDP-NBR-ADDR-INFO {
      description
        "MPLS LDP Neighbor Bound Address Information";
      container address {
        description "Neighbor Address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container address
    }  // grouping LDP-NBR-ADDR-INFO

    grouping LDP-TCP-INFO {
      description
        "MPLS LDP Neighbor TCP Information";
      container foreign-host {
        description "Foreign host address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container foreign-host

      container local-host {
        description "Local host address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container local-host

      leaf foreign-port {
        type uint16;
        description "Foreign port number";
      }

      leaf local-port {
        type uint16;
        description "Local port number";
      }

      leaf is-md5-on {
        type boolean;
        description "Is MD5 Digest on";
      }
    }  // grouping LDP-TCP-INFO

    grouping LDP-GR-ADJ-INFO {
      description
        "MPLS LDP Neighbor Graceful Restart Adjacency
       Information";
      leaf is-graceful-restartable {
        type boolean;
        description
          "Is graceful restartable";
      }

      leaf reconnect-timeout {
        type uint32;
        description "Reconnect timeout";
      }

      leaf recovery-time {
        type uint32;
        description "Recovery time";
      }
    }  // grouping LDP-GR-ADJ-INFO

    grouping LDP-PTCL-ADJ-INFO {
      description
        "MPLS LDP PTCL Adjacency Information";
      container ta-graceful-restart-adjacency {
        description
          "Graceful restart information";
        uses LDP-GR-ADJ-INFO;
      }  // container ta-graceful-restart-adjacency

      leaf ta-holdtime {
        type uint32;
        description
          "Session holdtime in sec";
      }

      leaf ta-state {
        type string;
        description "State";
      }

      leaf ta-pies-sent {
        type uint32;
        description "Number of pies sent";
      }

      leaf ta-pies-rcvd {
        type uint32;
        description
          "Number of pies received";
      }

      leaf ta-up-time-seconds {
        type uint32;
        units "second";
        description "Up time in seconds";
      }

      leaf downstream-on-demand {
        type boolean;
        description
          "Is Label advertisment mode in Downstream On
         Demand mode or Not";
      }
    }  // grouping LDP-PTCL-ADJ-INFO

    grouping LDP-NEIGHBOR-INFO {
      description
        "MPLS LDP Neighbor Information";
      container protocol-information {
        description "Protocol Information";
        uses LDP-PTCL-ADJ-INFO;
      }  // container protocol-information

      container tcp-information {
        description "TCP Information";
        uses LDP-TCP-INFO;
      }  // container tcp-information

      container detailed-information {
        description
          "Detailed information with regards to holdtime,
         KA, inbound filtering, and Session protection";
        uses LDP-NBR-DETAILED-INFO;
      }  // container detailed-information

      list ldp-nbr-bound-ipv4-address-info {
        description
          "Neighbor IPv4 Address Info";
        uses LDP-NBR-ADDR-INFO;
      }  // list ldp-nbr-bound-ipv4-address-info

      list ldp-nbr-bound-ipv6-address-info {
        description
          "Neighbor IPv6 Address Info";
        uses LDP-NBR-ADDR-INFO;
      }  // list ldp-nbr-bound-ipv6-address-info

      list ldp-nbr-ipv4-adj-info {
        description
          "Neighbor's IPv4 Adjacency Information";
        uses LDP-NBR-ADJ-INFO;
      }  // list ldp-nbr-ipv4-adj-info

      list ldp-nbr-ipv6-adj-info {
        description
          "Neighbor's IPv6 Adjacency Information";
        uses LDP-NBR-ADJ-INFO;
      }  // list ldp-nbr-ipv6-adj-info
    }  // grouping LDP-NEIGHBOR-INFO

    grouping LDP-NBR-CAP-INFO {
      description
        "MPLS LDP Neighbor Capability Information";
      list sent {
        description
          "List of sent capabilities";
        uses LDP-CAP-DESC;
      }  // list sent

      list received {
        description
          "List of received capabilities";
        uses LDP-CAP-DESC;
      }  // list received
    }  // grouping LDP-NBR-CAP-INFO

    grouping LDP-PARAMETERS-AF {
      description
        "MPLS LDP per AF Parameters Information";
      container discovery-transport-address {
        description
          "Discovery transport address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container discovery-transport-address

      leaf address-family {
        type Ldp-af;
        description "Address Family";
      }

      leaf null-label {
        type string;
        description "Null label";
      }

      leaf label-imp-null-override-acl {
        type string;
        description
          "ACL to override local label to use implicit-null";
      }

      leaf is-accepting-targeted-hellos {
        type boolean;
        description
          "Accepting targeted Hellos";
      }

      leaf targeted-hello-acl {
        type string;
        description "Targeted Hello ACL";
      }
    }  // grouping LDP-PARAMETERS-AF

    grouping LDP-GRACEFUL-RESTART-INFO {
      description
        "MPLS LDP Global Graceful Restart Information";
      leaf is-graceful-restart-configured {
        type boolean;
        description
          "Is graceful restart configured";
      }

      leaf graceful-restart-reconnect-timeout {
        type uint32;
        description
          "Reconnect timeout value";
      }

      leaf graceful-restart-forwarding-state-hold-time {
        type uint32;
        description
          "Graceful restart forward state hold time";
      }
    }  // grouping LDP-GRACEFUL-RESTART-INFO

    grouping LDP-PARAMETERS {
      description
        "MPLS LDP Global Parameters";
      container graceful-restart-information {
        description
          "Graceful restart information";
        uses LDP-GRACEFUL-RESTART-INFO;
      }  // container graceful-restart-information

      leaf role-is-active {
        type boolean;
        description
          "Is process role active or standby";
      }

      leaf global-md5-password-enabled {
        type boolean;
        description
          "Global MD5 password enabled";
      }

      leaf protocol-version {
        type uint32;
        description "Protocol version";
      }

      leaf router-id {
        type inet:ipv4-address;
        description "Router ID";
      }

      leaf keepalive-interval {
        type uint32;
        description "Keepalive interval";
      }

      leaf hello-hold-time {
        type uint32;
        description "Hello hold time";
      }

      leaf hello-interval {
        type uint32;
        description "Hello interval";
      }

      leaf targeted-hello-hold-time {
        type uint32;
        description
          "Targeted hello hold time";
      }

      leaf targeted-hello-interval {
        type uint32;
        description
          "Targeted hello interval";
      }

      leaf session-hold-time {
        type uint32;
        description "Session hold time";
      }

      leaf housekeeping-timer-interval {
        type uint32;
        description
          "Housekeeping periodic timer interval";
      }

      leaf le-no-route-timeout {
        type uint32;
        description
          "LIB entry no route timeout";
      }

      leaf ldp-recovery-timeout {
        type uint32;
        description
          "LDP recovery timeout with LSD";
      }

      leaf af-binding-withdraw-delay {
        type uint32;
        description
          "Delay (sec) in Binding Withdrawal for an Address
         Family";
      }

      leaf max-intf-attached {
        type uint32;
        description
          "Maximum number of LDP enabled attached
         interfaces";
      }

      leaf max-intf-te {
        type uint32;
        description
          "Maximum number of LDP enabled TE interfaces";
      }

      leaf max-peer {
        type uint32;
        description
          "Maximum number of LDP peers";
      }

      leaf ldp-out-of-mem-state {
        type uint32;
        description
          "LDP Out of memory state";
      }

      leaf nsr-enabled {
        type boolean;
        description "TRUE if NSR is enabled";
      }

      leaf nsr-synced {
        type boolean;
        description
          "TRUE if LDP is standby and is NSR Sync-ed with
         active";
      }

      leaf igp-sync-delay-time-for-interface {
        type uint32;
        units "second";
        description
          "Interface IGP sync delay time in seconds";
      }

      leaf igp-sync-delay-time-on-restart {
        type uint32;
        units "second";
        description
          "IGP sync delay time on process restart in
         seconds";
      }

      leaf global-discovery-quick-start-disabled {
        type boolean;
        description
          "Discovery quick-start globally disabled";
      }

      leaf discovery-quick-start-disabled-on-interfaces {
        type boolean;
        description
          "Discovery quick-start disabled on some
         LDP-enabled interfaces";
      }

      list address-family-parameter {
        description "Per AF parameters";
        uses LDP-PARAMETERS-AF;
      }  // list address-family-parameter
    }  // grouping LDP-PARAMETERS

    grouping LDP-NSR-SUM-SESS {
      description
        "MPLS LDP NSR session summary";
      leaf total {
        type uint32;
        description "Total sessions";
      }

      leaf nsr-eligible {
        type uint32;
        description "NSR eligible sessions";
      }

      leaf nsr-state-none {
        type uint32;
        description
          "Number of sessions in NSR none state";
      }

      leaf nsr-state-wait {
        type uint32;
        description
          "Number of sessions in NSR wait state";
      }

      leaf nsr-state-ready {
        type uint32;
        description
          "Number of sessions in NSR ready state";
      }

      leaf nsr-state-prepare {
        type uint32;
        description
          "Number of sessions in NSR prepare state";
      }

      leaf nsr-state-app-wait {
        type uint32;
        description
          "Number of sessions in NSR app-wait state";
      }

      leaf nsr-state-operational {
        type uint32;
        description
          "Number of sessions in NSR operational state";
      }

      leaf nsr-state-tcp-phase1 {
        type uint32;
        description
          "Number of sessions in NSR TCP phase 1 state";
      }

      leaf nsr-state-tcp-phase2 {
        type uint32;
        description
          "Number of sessions in NSR TCP phase 2 state";
      }
    }  // grouping LDP-NSR-SUM-SESS

    grouping LDP-NSR-SUM {
      description "MPLS LDP NSR summary";
      container vrf {
        description "VRF information";
        uses LDP-VRF-INFO;
      }  // container vrf

      container sessions {
        description "Session summary";
        uses LDP-NSR-SUM-SESS;
      }  // container sessions
    }  // grouping LDP-NSR-SUM

    grouping LDP-BACKOFF-ENTRY-INFO {
      description
        "MPLS LDP Session Backoff Entry Information";
      leaf backoff-seconds {
        type uint32;
        units "second";
        description "Backoff seconds";
      }

      leaf waiting-seconds {
        type uint32;
        units "second";
        description
          "Backoff waiting seconds";
      }
    }  // grouping LDP-BACKOFF-ENTRY-INFO

    grouping LDP-BACKOFF-INFO {
      description
        "MPLS LDP Session Backoff Information";
      leaf initial-seconds {
        type uint32;
        units "second";
        description
          "Initial backoff value in seconds";
      }

      leaf maximum-seconds {
        type uint32;
        units "second";
        description
          "Maximum backoff value in seconds";
      }
    }  // grouping LDP-BACKOFF-INFO

    grouping LDP-NEIGHBOR-BRIEF-AF-INFO {
      description
        "MPLS LDP Neighbor Brief AF information";
      leaf address-family {
        type Ldp-af;
        description
          "Neighbor Brief Address Family";
      }

      leaf num-of-nbr-discovery {
        type uint32;
        description
          "Number of neighbor discovery sources";
      }

      leaf num-of-nbr-addresses {
        type uint32;
        description
          "Number of neighbor addresses";
      }

      leaf num-of-nbr-lbl {
        type uint32;
        description
          "Number of neighbor labels";
      }
    }  // grouping LDP-NEIGHBOR-BRIEF-AF-INFO

    grouping LDP-NEIGHBOR-BRIEF-INFO {
      description
        "MPLS LDP Neighbor Brief Information";
      container vrf {
        description "VRF information";
        uses LDP-VRF-INFO;
      }  // container vrf

      leaf is-graceful-restartable {
        type boolean;
        description
          "Is graceful restartable";
      }

      leaf nsr-state {
        type Show-nsr-state;
        description "NSR readiness state";
      }

      leaf up-time-seconds {
        type uint32;
        units "second";
        description "Up time in seconds";
      }

      list nbr-br-af-info {
        max-elements 2;
        description "Neighbor Brief AF Info";
        uses LDP-NEIGHBOR-BRIEF-AF-INFO;
      }  // list nbr-br-af-info
    }  // grouping LDP-NEIGHBOR-BRIEF-INFO

    grouping LDP-FWD-RW-PATH-SUMM {
      description
        "MPLS LDP fowarding rewrite nexthop/path summary";
      leaf total-paths {
        type uint32;
        description "Total path count";
      }

      leaf protected-paths {
        type uint32;
        description
          "Count of FRR protected paths";
      }

      leaf backup-paths {
        type uint32;
        description
          "Count of non-primary backup paths";
      }

      leaf remote-backup-paths {
        type uint32;
        description
          "Count of non-primary remote backup paths";
      }

      leaf labeled-paths {
        type uint32;
        description
          "Count of all labeled paths";
      }

      leaf labeled-backup-paths {
        type uint32;
        description
          "Count of labeled backup paths";
      }
    }  // grouping LDP-FWD-RW-PATH-SUMM

    grouping LDP-FWD-RW-PFX-LBL-SUMM {
      description
        "MPLS LDP forwarding rewrite prefix nexthops
       labeled summary";
      leaf labeled-pfxs {
        type uint16;
        description
          "Count of labeled prefixes with 1 or more paths
         labeled";
      }

      leaf labeled-pfxs-partial {
        type uint16;
        description
          "Count of labeled prefixes with some (but not
         ALL) paths labeled";
      }

      leaf unlabeled-pfxs {
        type uint16;
        description
          "Count of labeled prefixes with ALL paths
         unlabeled";
      }
    }  // grouping LDP-FWD-RW-PFX-LBL-SUMM

    grouping LDP-FWD-RW-PFX-SUMM {
      description
        "MPLS LDP fowarding rewrite prefix summary";
      container labeled-pfxs-aggr {
        description
          "Labeled prefix count for all paths";
        uses LDP-FWD-RW-PFX-LBL-SUMM;
      }  // container labeled-pfxs-aggr

      container labeled-pfxs-primary {
        description
          "Labeled prefix count related to primary paths
         only";
        uses LDP-FWD-RW-PFX-LBL-SUMM;
      }  // container labeled-pfxs-primary

      container labeled-pfxs-backup {
        description
          "Labeled prefix count related to backup paths
         only";
        uses LDP-FWD-RW-PFX-LBL-SUMM;
      }  // container labeled-pfxs-backup

      leaf total-pfxs {
        type uint16;
        description "Total Prefix count";
      }

      leaf ecmp-pfxs {
        type uint16;
        description
          "Count of prefixes with ECMP";
      }

      leaf protected-pfxs {
        type uint16;
        description
          "Count of FRR protected prefixes";
      }
    }  // grouping LDP-FWD-RW-PFX-SUMM

    grouping LDP-FWD-RW-SUMM {
      description
        "MPLS LDP fowarding rewrite summary";
      container pfxs {
        description
          "Forwarding rewrites prefix summary";
        uses LDP-FWD-RW-PFX-SUMM;
      }  // container pfxs

      container nhs {
        description
          "Forwarding rewrites nexthops (paths) summary";
        uses LDP-FWD-RW-PATH-SUMM;
      }  // container nhs
    }  // grouping LDP-FWD-RW-SUMM

    grouping LDP-FWD-SUMM-INFO {
      description
        "MPLS LDP fowarding summary";
      container vrf {
        description "VRF information";
        uses LDP-VRF-INFO;
      }  // container vrf

      container rws {
        description
          "Forwarding rewrites summary";
        uses LDP-FWD-RW-SUMM;
      }  // container rws

      leaf is-lsd-bound {
        type boolean;
        description
          "LDP is connected to LSD server";
      }

      leaf fsht {
        type uint16;
        description
          "Forwarding state hold time registered with LSD";
      }

      leaf intfs {
        type uint16;
        description
          "MPLS forwarding enabled interface count";
      }

      leaf lbls {
        type uint16;
        description
          "Local label allocated count";
      }
    }  // grouping LDP-FWD-SUMM-INFO

    grouping LDP-BINDING-ALLOC {
      description
        "MPLS LDP Binding local label allocation filter";
      leaf has-acl {
        type boolean;
        description "Has ACL filter?";
      }

      leaf prefix-acl {
        type string {
          length "0..64";
        }
        description "Prefix ACL";
      }

      leaf is-host-route-only {
        type boolean;
        description "Host-routes only?";
      }
    }  // grouping LDP-BINDING-ALLOC

    grouping LDP-BINDING-ADVT-ACL-PAIR {
      description
        "MPLS LDP Binding advertisement ACL pair";
      leaf prefix-acl {
        type string {
          length "0..64";
        }
        description "Prefix ACL";
      }

      leaf peer-acl {
        type string {
          length "0..64";
        }
        description "Peer ACL";
      }
    }  // grouping LDP-BINDING-ADVT-ACL-PAIR

    grouping LDP-BINDING-ADVT-SPEC {
      description
        "MPLS LDP Binding advertisement specification ACLs";
      container allocation-acl {
        description
          "Local label Allocation filter";
        uses LDP-BINDING-ALLOC;
      }  // container allocation-acl

      list advt-acl {
        description "Advertisement ACLs";
        uses LDP-BINDING-ADVT-ACL-PAIR;
      }  // list advt-acl
    }  // grouping LDP-BINDING-ADVT-SPEC

    grouping LDP-FWD-PATH-RLFA-MOI-INFO {
      description
        "MPLS LDP Forwarding Path Remote LFA-FRR backup
       MPLS MOI info";
      list stack {
        description "Inner label stack info";
        uses LDP-FWD-PATH-MPLS-NH-INFO;
      }  // list stack
    }  // grouping LDP-FWD-PATH-RLFA-MOI-INFO

    grouping LDP-FWD-PATH-RLFA-MPLS-INFO {
      description
        "MPLS LDP Forwarding Path Remote LFA-FRR backup
       MPLS info";
      container mpls-outgoing-info {
        description
          "Remote LFA MPLS nexthop(s_ info";
        uses LDP-FWD-PATH-RLFA-MOI-INFO;
      }  // container mpls-outgoing-info

      leaf has-remote-lfa-bkup {
        type boolean;
        description
          "Whether path has remote LFA backup";
      }
    }  // grouping LDP-FWD-PATH-RLFA-MPLS-INFO

    grouping LDP-FWD-PATH-MPLS-NH-INFO {
      description
        "Forwarding Path MPLS nexthop info";
      container nexthop-peer-ldp-ident {
        description "Nexthop LDP peer";
        uses LDP-LDPID-INFO;
      }  // container nexthop-peer-ldp-ident

      leaf out-label {
        type uint32;
        description "Outgoing label";
      }

      leaf out-label-rsn {
        type Ldp-fwd-unlbl-rsn;
        description "Outgoing label reason";
      }

      leaf out-label-type {
        type Label-value;
        description "Outgoing Label Type";
      }

      leaf out-label-owner {
        type Ldp-route-path-lbl-owner;
        description "Outgoing label owner";
      }

      leaf is-from-graceful-restartable-neighbor {
        type boolean;
        description "Is from a GR neighbor";
      }

      leaf is-stale {
        type boolean;
        description "Is the entry stale";
      }

      leaf entropy-label-capability {
        type boolean;
        description
          "Entropy Label Capability";
      }
    }  // grouping LDP-FWD-PATH-MPLS-NH-INFO

    grouping LDP-FWD-PATH-MPLS-INFO {
      description
        "MPLS LDP Forwarding Path MPLS information";
      container mpls-outgoing-info {
        description "MPLS nexthop info";
        uses LDP-FWD-PATH-MPLS-NH-INFO;
      }  // container mpls-outgoing-info

      container remote-lfa {
        description
          "Remote LFA-FRR backup info";
        uses LDP-FWD-PATH-RLFA-MPLS-INFO;
      }  // container remote-lfa
    }  // grouping LDP-FWD-PATH-MPLS-INFO

    grouping LDP-FWD-PATH-RLFA-ROUTING-INFO {
      description
        "MPLS LDP Forwarding Path Remote LFA-FRR backup
       routing info";
      container remote-p-node-id {
        description "Remote/P node address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container remote-p-node-id

      container remote-q-node-id {
        description "Remote/Q node address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container remote-q-node-id

      leaf has-remote-lfa-bkup {
        type boolean;
        description
          "Whether path has remote LFA backup";
      }

      leaf needs-tldp {
        type boolean;
        description
          "Whether TLDP is needed with remote PQ node";
      }

      leaf has-q-node {
        type boolean;
        description
          "Whether remote LFA path has a Q node associated";
      }
    }  // grouping LDP-FWD-PATH-RLFA-ROUTING-INFO

    grouping LDP-FWD-PATH-ROUTING-INFO {
      description
        "MPLS LDP Forwarding Path IP Routing information";
      container next-hop {
        description "Next Hop";
        uses LDP-IP-ADDR-T-UNION;
      }  // container next-hop

      container remote-lfa {
        description
          "Remote LFA-FRR backup info";
        uses LDP-FWD-PATH-RLFA-ROUTING-INFO;
      }  // container remote-lfa

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

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

      leaf nh-is-overriden {
        type boolean;
        description
          "Nexthop is overriden by LDP";
      }

      leaf nexthop-id {
        type uint32;
        description "Nexthop Identifier";
      }

      leaf next-hop-table-id {
        type uint32;
        description
          "Table ID for nexthop address";
      }

      leaf flags {
        type uint32;
        description "Route path flags";
      }

      leaf load-metric {
        type uint32;
        description
          "Path's load metric for load balancing";
      }

      leaf binding-label {
        type uint32;
        description
          "Binding label obtained via RIB";
      }

      leaf path-id {
        type uint8;
        description "path Id";
      }

      leaf bkup-path-id {
        type uint8;
        description "Backup path Id";
      }

      leaf path-flags {
        type Ldp-route-path-flags;
        description
          "Routing path flags decoded";
      }
    }  // grouping LDP-FWD-PATH-ROUTING-INFO

    grouping LDP-FWD-PATH-INFO {
      description
        "MPLS LDP Forwarding Path info";
      container routing {
        description "IP routing information";
        uses LDP-FWD-PATH-ROUTING-INFO;
      }  // container routing

      container mpls {
        description "MPLS information";
        uses LDP-FWD-PATH-MPLS-INFO;
      }  // container mpls
    }  // grouping LDP-FWD-PATH-INFO

    grouping LDP-FWD-ROUTE-MPLS-INFO {
      description
        "MPLS LDP Forwarding Route LDP information";
      leaf local-label {
        type uint32;
        description "Local label";
      }

      leaf forwarding-update-count {
        type uint32;
        description
          "Number of forwarding updates";
      }

      leaf forwarding-update-timestamp {
        type uint64;
        description
          "Last Forwarding update nanosec timestamp";
      }

      leaf forwarding-update-age {
        type uint64;
        description
          "Last Forwarding update nanosec age";
      }
    }  // grouping LDP-FWD-ROUTE-MPLS-INFO

    grouping LDP-FWD-ROUTE-ROUTING-INFO {
      description
        "MPLS LDP Forwarding Route IP Routing information";
      leaf version {
        type uint32;
        description "Route RIB ersion";
      }

      leaf priority {
        type uint8;
        description "Route priority";
      }

      leaf source {
        type uint16;
        description "Route source protol Id";
      }

      leaf type {
        type uint16;
        description "Route type";
      }

      leaf flags {
        type uint32;
        description "Route RIB flags";
      }

      leaf metric {
        type uint32;
        description "Route metric";
      }

      leaf is-local-vrf-leaked {
        type boolean;
        description
          "Is route leaked across local VRFs?";
      }

      leaf routing-update-count {
        type uint32;
        description
          "Number of routing updates";
      }

      leaf routing-update-timestamp {
        type uint64;
        description
          "Last Routing update nanosec timestamp";
      }

      leaf routing-update-age {
        type uint64;
        description
          "Last Routing update nanosec age";
      }

      leaf sr-local-label {
        type uint32;
        description "SR Local-label";
      }
    }  // grouping LDP-FWD-ROUTE-ROUTING-INFO

    grouping LDP-FWD-ROUTE-INFO {
      description
        "MPLS LDP Forwarding Route information";
      container routing {
        description "IP routing information";
        uses LDP-FWD-ROUTE-ROUTING-INFO;
      }  // container routing

      container mpls {
        description "MPLS information";
        uses LDP-FWD-ROUTE-MPLS-INFO;
      }  // container mpls
    }  // grouping LDP-FWD-ROUTE-INFO

    grouping LDP-FWD-PFX-INFO {
      description
        "MPLS LDP Forwarding Prefix Information";
      container vrf {
        description "VRF information";
        uses LDP-VRF-INFO;
      }  // container vrf

      container prefix-xr {
        description "IP Prefix";
        uses LDP-IP-ADDR-T-UNION;
      }  // container prefix-xr

      container route {
        description "Route";
        uses LDP-FWD-ROUTE-INFO;
      }  // container route

      leaf table-id {
        type uint32;
        description
          "Table ID associated with IP prefix";
      }

      leaf prefix-length {
        type uint8;
        description "Prefix length";
      }

      list paths {
        description "Paths";
        uses LDP-FWD-PATH-INFO;
      }  // list paths
    }  // grouping LDP-FWD-PFX-INFO

    grouping LDP-DISCOVERY-ADJ-GRP-INFO {
      description
        "MPLS LDP Discovery Adjacency Group Information";
      leaf adjacency-group-up-time {
        type uint32;
        units "second";
        description
          "Adjacency group up time in seconds";
      }

      leaf tcp-open-count {
        type uint32;
        description
          "Count of attempted TCP opens";
      }

      leaf tcp-arb-chg-count {
        type uint32;
        description
          "Count of changes in TCP arbitration";
      }

      leaf tcp-role {
        type uint32;
        description "TCP Role";
      }
    }  // grouping LDP-DISCOVERY-ADJ-GRP-INFO

    grouping LDP-TARGETED-HELLO-BRIEF-INFO {
      description
        "MPLS LDP Discovery Targeted Brief Information";
      container vrf {
        description "VRF information";
        uses LDP-VRF-INFO;
      }  // container vrf

      container dhcb-target-address {
        description "DHCB target address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container dhcb-target-address

      leaf address-family {
        type Ldp-af;
        description
          "Targeted Discovery Address Family";
      }

      list hello-information {
        description "LDP hello info";
        uses LDP-HELLO-BRIEF-INFO;
      }  // list hello-information
    }  // grouping LDP-TARGETED-HELLO-BRIEF-INFO

    grouping LDP-HELLO-BRIEF-INFO {
      description
        "MPLS LDP Hello Brief Information";
      leaf neighbor-ldp-identifier {
        type string;
        description
          "Neighbor LDP Identifier";
      }

      leaf hold-time {
        type uint32;
        description
          "Session hold time in sec";
      }

      leaf session-up {
        type boolean;
        description
          "Is session up for this adj";
      }
    }  // grouping LDP-HELLO-BRIEF-INFO

    grouping LDP-DISCOVERY-LINK-BRIEF-INFO {
      description
        "MPLS LDP Discovery Link Brief Information";
      container vrf {
        description "VRF information";
        uses LDP-VRF-INFO;
      }  // container vrf

      leaf address-family {
        type Ldp-af;
        description
          "Discovery Brief Address Family";
      }

      leaf address-family-set {
        type Ldp-af;
        description
          "Discovery Brief Address Family Set";
      }

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

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

      list hello-information {
        description "LDP hello info";
        uses LDP-HELLO-BRIEF-INFO;
      }  // list hello-information
    }  // grouping LDP-DISCOVERY-LINK-BRIEF-INFO

    grouping LDP-TARGETED-HELLO-INFO {
      description
        "MPLS LDP Targeted Hello Information";
      container dhcb-local-address {
        description "DHCB local address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container dhcb-local-address

      container dhcb-target-address {
        description "DHCB target address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container dhcb-target-address

      leaf state {
        type Dhcb-state;
        description "Targeted hello state";
      }

      leaf adjacency-ldp-identifier {
        type string;
        description
          "Adjacency LDP Identifier";
      }

      leaf interval {
        type uint32;
        description "Hello interval in sec";
      }

      leaf next-hello {
        type uint32;
        description
          "Next hello due time in msec";
      }

      leaf hold-time {
        type uint32;
        description
          "Targeted hello hold time";
      }

      leaf local-hold-time {
        type uint32;
        description "Local hold time";
      }

      leaf neighbor-hold-time {
        type uint32;
        description "Neighbor hold time";
      }

      leaf disc-expiry {
        type uint32;
        description
          "Discovery expiry time in msec";
      }

      leaf quick-start-disabled {
        type boolean;
        description "Quick-start disabled";
      }

      leaf established-time {
        type uint64;
        description
          "Hello adjacency estabished time in nanosec";
      }

      leaf established-age {
        type uint64;
        description
          "Hello adjacency estabished age in nanosec";
      }

      leaf session-up {
        type boolean;
        description
          "Is session up for this adj";
      }

      leaf session-bringup-failure-reason {
        type string;
        description
          "session bringup failure reason";
      }

      list last-session-down-info {
        description
          "Last session down information";
        uses LDP-LAST-SESS-INFO;
      }  // list last-session-down-info
    }  // grouping LDP-TARGETED-HELLO-INFO

    grouping LDP-DISCOVERY-SUMMARY-INFO {
      description
        "MPLS LDP Discovery Summary Information";
      container vrf {
        description "VRF information";
        uses LDP-VRF-INFO;
      }  // container vrf

      leaf local-ldp-id {
        type string;
        description "Local LDP identifier";
      }

      leaf num-of-ldp-interfaces {
        type uint32;
        description
          "Total Number of LDP configured interfaces";
      }

      leaf num-of-active-ldp-interfaces {
        type uint32;
        description
          "Number of active LDP enabled interfaces";
      }

      leaf num-of-lnk-disc-xmit {
        type uint32;
        description
          "Number of link hello discoveries in xmit state";
      }

      leaf num-of-tgt-disc-xmit {
        type uint32;
        description
          "Number of targeted hello discoveries in xmit
         state";
      }

      leaf num-of-lnk-disc-recv {
        type uint32;
        description
          "Number of link hello discoveries in recv state";
      }

      leaf num-of-tgt-disc-recv {
        type uint32;
        description
          "Number of targeted hello discoveries in recv
         state";
      }

      leaf num-of-disc-with-bad-addr-recv {
        type uint32;
        description
          "Number of hello discoveries received with bad
         source address";
      }

      leaf num-of-disc-with-bad-hello-pdu {
        type uint32;
        description
          "Number of hello discoveries received with bad
         hello PDU";
      }

      leaf num-of-disc-with-bad-xport-addr {
        type uint32;
        description
          "Number of hello discoveries received with bad
         export address";
      }

      leaf num-of-disc-with-same-router-id {
        type uint32;
        description
          "Number of hello discoveries received with the
         same router id as this router";
      }

      leaf num-of-disc-with-wrong-router-id {
        type uint32;
        description
          "Number of hello discoveries received with the
         router id that is not destined for this router";
      }
    }  // grouping LDP-DISCOVERY-SUMMARY-INFO

    grouping LDP-DISCOVERY-LINK-AF-INFO {
      description
        "MPLS LDP Discovery Link Address Family
       Information";
      container local-src-address {
        description "Local source address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container local-src-address

      container local-transport-address {
        description
          "Local transport address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container local-transport-address

      leaf interval {
        type uint32;
        description "Hello interval in sec";
      }
    }  // grouping LDP-DISCOVERY-LINK-AF-INFO

    grouping LDP-LAST-SESS-INFO {
      description
        "LDP last down session information";
      leaf last-session-down-reason {
        type string;
        description
          "The reason of last socket failure";
      }

      leaf last-session-down-time {
        type uint64;
        description
          "Timestamp of when the last session went down";
      }

      leaf last-session-up-time {
        type uint32;
        description
          "The time duration the last session was up";
      }
    }  // grouping LDP-LAST-SESS-INFO

    grouping LDP-HELLO-INFO {
      description
        "MPLS LDP Hello Information";
      container neighbor-src-address {
        description
          "Neighbor source address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container neighbor-src-address

      container neighbor-transport-address {
        description
          "Neighbor transport address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container neighbor-transport-address

      container target {
        description "Target address";
        uses LDP-IP-ADDR-T-UNION;
      }  // container target

      leaf neighbor-ldp-identifier {
        type string;
        description
          "Neighbor LDP Identifier";
      }

      leaf is-no-route {
        type boolean;
        description "Is route valid";
      }

      leaf hold-time {
        type uint32;
        units "second";
        description
          "Session hold time in seconds";
      }

      leaf local-hold-time {
        type uint32;
        units "second";
        description
          "Local hold time in seconds";
      }

      leaf neighbor-hold-time {
        type uint32;
        units "second";
        description
          "Neighbor hold time in seconds";
      }

      leaf disc-expiry {
        type uint32;
        description
          "Discovery expiry time in sec";
      }

      leaf is-targeted {
        type boolean;
        description
          "Is session a targeted session";
      }

      leaf session-up {
        type boolean;
        description
          "Is session up for this adj";
      }

      leaf established-time {
        type uint64;
        description
          "Hello adjacency estabished time in nanosec";
      }

      leaf established-age {
        type uint64;
        description
          "Hello adjacency estabished age in nanosec";
      }

      leaf session-bringup-failure-reason {
        type string;
        description
          "session bringup failure reason";
      }

      list last-session-down-info {
        description
          "Last session down information";
        uses LDP-LAST-SESS-INFO;
      }  // list last-session-down-info
    }  // grouping LDP-HELLO-INFO

    grouping LDP-DISCOVERY-LINK-INFO {
      description
        "MPLS LDP Discovery Link Information";
      container vrf {
        description "VRF information";
        uses LDP-VRF-INFO;
      }  // container vrf

      leaf next-hello {
        type uint32;
        description
          "Next hello due time in msec";
      }

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

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

      leaf quick-start-disabled {
        type boolean;
        description "Quick-start disabled";
      }

      list hello-information {
        description "LDP hello info";
        uses LDP-HELLO-INFO;
      }  // list hello-information

      list discovery-link-af {
        max-elements 2;
        description "LDP hello AF info";
        uses LDP-DISCOVERY-LINK-AF-INFO;
      }  // list discovery-link-af
    }  // grouping LDP-DISCOVERY-LINK-INFO

    grouping LDP-INTF-AUTOCFG {
      description "MPLS LDP auto configure";
      leaf tuple {
        type string;
        description "Tuple";
      }
    }  // grouping LDP-INTF-AUTOCFG

    grouping LDP-INTF-TE-MESH-GRP {
      description
        "MPLS LDP interface tunnel mesh group";
      leaf ldp-te-mesh-group-all-cfgd {
        type boolean;
        description
          "LDP has enabled all TE mesh-groups";
      }

      leaf ldp-mesh-group-enabled {
        type boolean;
        description
          "LDP has enabled this TE mesh-group";
      }

      leaf te-mesh-group-id {
        type uint32;
        description
          "TE tunnel Mesh Group ID";
      }
    }  // grouping LDP-INTF-TE-MESH-GRP

    grouping LDP-INTF {
      description
        "MPLS LDP interface information";
      container vrf {
        description "VRF information";
        uses LDP-VRF-INFO;
      }  // container vrf

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

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

      leaf ldp-enabled {
        type boolean;
        description "LDP enabled";
      }

      leaf is-im-stale {
        type boolean;
        description
          "Is IM information stale";
      }

      leaf ldp-config-mode {
        type boolean;
        description "LDP config mode";
      }

      leaf ldp-autoconfig-disable {
        type boolean;
        description "LDP autoconfig disable";
      }

      list te-mesh-grp {
        description "TE tunnel mesh-group";
        uses LDP-INTF-TE-MESH-GRP;
      }  // list te-mesh-grp

      list auto-config {
        description "Auto config";
        uses LDP-INTF-AUTOCFG;
      }  // list auto-config
    }  // grouping LDP-INTF

    grouping LDP-BINDING-SUMMARY-AF {
      description
        "MPLS LDP Binding Summary AF Information";
      leaf address-family {
        type Ldp-af;
        description
          "Binding Summary Address Family";
      }

      leaf last-lib-update {
        type uint32;
        description
          "Last update to LIB local binding";
      }

      leaf lib-minimum-revision-sent-all {
        type uint32;
        description
          "Last update sent to all peers";
      }

      leaf binding-total {
        type uint32;
        description "Total bindings";
      }

      leaf binding-local {
        type uint32;
        description
          "Number of local bindings";
      }

      leaf binding-remote {
        type uint32;
        description
          "Number of remote bindings";
      }
    }  // grouping LDP-BINDING-SUMMARY-AF

    grouping LDP-BINDING-SUMMARY {
      description
        "MPLS LDP Binding Summary Information";
      container vrf {
        description "VRF information";
        uses LDP-VRF-INFO;
      }  // container vrf

      leaf address-family {
        type Ldp-af;
        description "Address Family";
      }

      leaf binding-no-route {
        type uint32;
        description "Bindings with no route";
      }

      leaf binding-local-no-route {
        type uint32;
        description
          "Local bindings with no route";
      }

      leaf binding-local-null {
        type uint32;
        description
          "Number of local null bindings";
      }

      leaf binding-local-implicit-null {
        type uint32;
        description
          "Number of local implicit null bindings";
      }

      leaf binding-local-explicit-null {
        type uint32;
        description
          "Number of local explicit null bindings";
      }

      leaf binding-local-non-null {
        type uint32;
        description
          "Number of local non-null bindings";
      }

      leaf binding-local-oor {
        type uint32;
        description
          "Number of local bindings        needing label -
         OOR";
      }

      leaf lowest-allocated-label {
        type uint32;
        description "Lowest allocated label";
      }

      leaf highest-allocated-label {
        type uint32;
        description
          "Highest allocated label";
      }

      list bind-af {
        max-elements 2;
        description "bind af";
        uses LDP-BINDING-SUMMARY-AF;
      }  // list bind-af
    }  // grouping LDP-BINDING-SUMMARY

    grouping LDP-IGP-SYNC-DELAY-RESTART-INFO {
      description
        "MPLS LDP IGP Sync Restart Delay Information";
      leaf configured {
        type boolean;
        description
          "Is restart delay configured";
      }

      leaf delay-secs {
        type uint32;
        description "Delay time";
      }

      leaf timer-running {
        type boolean;
        description
          "Is restart delay timer running";
      }

      leaf remaining-secs {
        type uint32;
        description
          "Delay timer remaining time";
      }
    }  // grouping LDP-IGP-SYNC-DELAY-RESTART-INFO

    grouping LDP-IGP-SYNC-INTF-GR-ONLY {
      description
        "MPLS LDP IGP Sync Interface GR-only reachable
       Peer Information";
      leaf peer-id {
        type String-td2;
        description "Peer Identifier";
      }

      leaf is-chkpt-created {
        type boolean;
        description
          "Is created due to checkpointing";
      }
    }  // grouping LDP-IGP-SYNC-INTF-GR-ONLY

    grouping LDP-IGP-SYNC-INTF-PEER {
      description
        "MPLS LDP IGP Sync Interface Peer Information";
      leaf peer-id {
        type String-td2;
        description "Peer Identifier";
      }

      leaf is-gr-enabled {
        type boolean;
        description "Is GR enabled session";
      }
    }  // grouping LDP-IGP-SYNC-INTF-PEER

    grouping LDP-IGP-SYNC-INFO {
      description
        "MPLS LDP IGP Sync Information";
      container vrf {
        description "VRF information";
        uses LDP-VRF-INFO;
      }  // container vrf

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

      leaf igp-sync-state {
        type Ldp-igp-sync-state;
        description "IGP Sync state";
      }

      leaf igp-sync-delay {
        type uint32;
        units "second";
        description
          "IGP sync delay in seconds";
      }

      leaf is-delay-timer-running {
        type boolean;
        description
          "Is sync delay timer running";
      }

      leaf delay-timer-remaining {
        type uint32;
        units "second";
        description
          "Remaining timer (seconds) till expiry of sync
         delay timer";
      }

      leaf igp-sync-down-reason {
        type Ldp-igp-sync-down-reason;
        description
          "Reason IGP Sync Not Achieved";
      }

      list peers {
        description "Interface Peers";
        uses LDP-IGP-SYNC-INTF-PEER;
      }  // list peers

      list gr-only-peer {
        description
          "Interface GR-only reachable peers";
        uses LDP-IGP-SYNC-INTF-GR-ONLY;
      }  // list gr-only-peer
    }  // grouping LDP-IGP-SYNC-INFO

    grouping LDP-TIB-ENTRY-REMOTE {
      description
        "MPLS LDP Remote Binding Information";
      container assigning-peer-ldp-ident {
        description "Assigning peer";
        uses LDP-LDPID-INFO;
      }  // container assigning-peer-ldp-ident

      leaf remote-label {
        type uint32;
        description "Remote Label";
      }

      leaf is-stale {
        type boolean;
        description "Is the entry stale";
      }

      leaf is-elc {
        type boolean;
        description
          "Is the entry entropy label capable";
      }
    }  // grouping LDP-TIB-ENTRY-REMOTE

    grouping LDP-TIB-ENTRY-DETAIL {
      description
        "MPLS LDP Binding Detail Information";
      container vrf {
        description "VRF information";
        uses LDP-VRF-INFO;
      }  // container vrf

      container prefix-xr {
        description "IP Prefix";
        uses LDP-IP-ADDR-T-UNION;
      }  // container prefix-xr

      leaf prefix-length {
        type uint8;
        description "Prefix Length";
      }

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

      leaf le-local-binding-revision {
        type uint32;
        description "Local Binding revision";
      }

      leaf le-local-label-state {
        type Local-label-state;
        description "Local label state";
      }

      leaf is-no-route {
        type boolean;
        description "No route";
      }

      leaf label-oor {
        type boolean;
        description
          "Label space depletion OOR";
      }

      leaf advertise-prefix-acl {
        type string;
        description "Advertise Prerfix ACL";
      }

      leaf advertise-tsr-acl {
        type string;
        description "Advertise TSR ACL";
      }

      leaf config-enforced-local-label-value {
        type boolean;
        description
          "Config/User enforced local label value";
      }

      leaf is-elc {
        type boolean;
        description
          "Is the entry entropy label capable";
      }

      list remote-binding {
        description "Remote binding";
        uses LDP-TIB-ENTRY-REMOTE;
      }  // list remote-binding

      list peers-advertised-to {
        description
          "Peers this entry is advertised to";
        uses LDP-LDPID-INFO;
      }  // list peers-advertised-to

      list peers-acked {
        description
          "Peers that have ACKed this entry";
        uses LDP-LDPID-INFO;
      }  // list peers-acked
    }  // grouping LDP-TIB-ENTRY-DETAIL

    grouping LDP-INTF-SUM {
      description
        "MPLS LDP interface summary";
      leaf known-ip-interface-count {
        type uint32;
        description
          "Number of known IP Interfaces";
      }

      leaf known-ip-interface-ldp-enabled {
        type uint32;
        description
          "Number of known IP Interfaces with LDP Enabled";
      }

      leaf ldp-configured-attached-interface {
        type uint32;
        description
          "Number of attached interfaces configured in LDP";
      }

      leaf ldp-configured-te-interface {
        type uint32;
        description
          "Number of TE tunnel interfaces configured in LDP";
      }

      leaf forward-references {
        type uint32;
        description
          "Number of forward referenced interfaces";
      }

      leaf auto-config-disabled {
        type uint32;
        description "Autoconfigure disabled";
      }

      leaf auto-config {
        type uint32;
        description
          "Auto-configured interfaces";
      }

      leaf auto-config-forward-reference-interfaces {
        type uint32;
        description
          "Auto-configured forward references";
      }
    }  // grouping LDP-INTF-SUM

    grouping LDP-SUMMARY-COMMON {
      description
        "MPLS LDP common summary Information";
      leaf address-families {
        type Ldp-af;
        description
          "Address Families enabled";
      }

      leaf number-of-ipv4af {
        type uint32;
        description
          "Number of IPv4 address-families enabled";
      }

      leaf number-of-ipv6af {
        type uint32;
        description
          "Number of IPv6 address-families enabled";
      }

      leaf number-of-neighbors {
        type uint32;
        description "Number of neighbors";
      }

      leaf number-of-adj-grps {
        type uint32;
        description
          "Number of Adjacency Groups";
      }

      leaf number-of-nsr-synced-neighbors {
        type uint32;
        description
          "Number of NSR-synced/operational neighbors";
      }

      leaf number-of-graceful-restart-neighbors {
        type uint32;
        description
          "Number of Graceful Restart neighbors";
      }

      leaf number-of-downstream-on-demand-neighbors {
        type uint32;
        description
          "Number of Downstream-On-Demand neighbors";
      }

      leaf number-of-ipv4-hello-adj {
        type uint32;
        description
          "Number of LDP discovery IPv4 hello adjacencies";
      }

      leaf number-of-ipv6-hello-adj {
        type uint32;
        description
          "Number of LDP discovery IPv6 hello adjacencies";
      }

      leaf number-of-ipv4-routes {
        type uint32;
        description
          "Number of resolved IPv4 routes";
      }

      leaf number-of-ipv6-routes {
        type uint32;
        description
          "Number of resolved IPv6 routes";
      }

      leaf number-of-ipv4-local-addresses {
        type uint32;
        description
          "Number of IPv4 local addresses";
      }

      leaf number-of-ipv6-local-addresses {
        type uint32;
        description
          "Number of IPv6 local addresses";
      }

      leaf number-of-ldp-interfaces {
        type uint32;
        description
          "Number of LDP configured interfaces";
      }

      leaf number-of-ipv4ldp-interfaces {
        type uint32;
        description
          "Number of LDP IPv4 configured interfaces";
      }

      leaf number-of-ipv6ldp-interfaces {
        type uint32;
        description
          "Number of LDP IPv6 configured interfaces";
      }

      leaf number-of-bindings-ipv4 {
        type uint32;
        description
          "Total number of ipv4 bindings";
      }

      leaf number-of-bindings-ipv6 {
        type uint32;
        description
          "Total number of ipv6 bindings";
      }

      leaf number-of-local-bindings-ipv4 {
        type uint32;
        description
          "Total number of ipv4 local label bindings";
      }

      leaf number-of-local-bindings-ipv6 {
        type uint32;
        description
          "Total number of ipv6 local label bindings";
      }

      leaf number-of-remote-bindings-ipv4 {
        type uint32;
        description
          "Total number of ipv4 remote label bindings";
      }

      leaf number-of-remote-bindings-ipv6 {
        type uint32;
        description
          "Total number of ipv6 remote label bindings";
      }
    }  // grouping LDP-SUMMARY-COMMON

    grouping LDP-SUMMARY-VRF {
      description
        "MPLS LDP per VRF summarized Information";
      container vrf {
        description "VRF information";
        uses LDP-VRF-INFO;
      }  // container vrf

      container common {
        description
          "Common Summary information";
        uses LDP-SUMMARY-COMMON;
      }  // container common
    }  // grouping LDP-SUMMARY-VRF

    grouping LDP-CAP-DESC {
      description
        "MPLS LDP Capability Description";
      leaf type {
        type uint16;
        description
          "Capability type (IANA assigned)";
      }

      leaf description {
        type string {
          length "0..80";
        }
        description "Capability description";
      }

      leaf capability-data-length {
        type uint16;
        description "Capability data length";
      }

      leaf capability-data {
        type string;
        description "Capability data";
      }
    }  // grouping LDP-CAP-DESC

    grouping LDP-CAP-INFO {
      description
        "MPLS LDP Capability Information";
      container capability {
        description "Capability information";
        uses LDP-CAP-DESC;
      }  // container capability

      leaf capability-owner {
        type string;
        description "Capability owner";
      }
    }  // grouping LDP-CAP-INFO

    grouping LDP-IP-ADDR-T-UNION {
      description "LDP IP ADDR T UNION";
      leaf afi {
        type Ldp-af-id;
        description "AFI";
      }

      leaf dummy {
        when "../afi = 'ldp-af-id-none'" {
          description
            "../AFI = 'LDP_AF_ID_NONE'";
        }
        type uint8;
        description "No Address";
      }

      leaf ipv4 {
        when "../afi = 'ldp-af-id-ipv4'" {
          description
            "../AFI = 'LDP_AF_ID_IPV4'";
        }
        type Ldp-in-addr;
        description "IPv4 address type";
      }

      leaf ipv6 {
        when "../afi = 'ldp-af-id-ipv6'" {
          description
            "../AFI = 'LDP_AF_ID_IPV6'";
        }
        type Ldp-in6-addr;
        description "IPv6 address type";
      }
    }  // grouping LDP-IP-ADDR-T-UNION

    grouping LDP-GR-DNBR-INTF-INFO {
      description
        "MPLS LDP GR DownNbr Interface Info";
      leaf address-family {
        type Ldp-af-id;
        description
          "Interface adj Address Family";
      }

      leaf interface-handle {
        type xr:Interface-name;
        description "Interfaces handle";
      }
    }  // grouping LDP-GR-DNBR-INTF-INFO

    grouping LDP-LDPID-INFO {
      description
        "MPLS LDP Identifier Information";
      leaf lsr-id {
        type inet:ipv4-address;
        description "LSR identifier";
      }

      leaf label-space-id {
        type uint16;
        description "Label space identifier";
      }

      leaf ldp-id {
        type string;
        description "LDP identifier";
      }
    }  // grouping LDP-LDPID-INFO

    grouping LDP-GR-NBR-INFO {
      description
        "MPLS LDP Graceful Restart Neighbor Information";
      container gr-peer {
        description "GR peer LDP Id";
        uses LDP-LDPID-INFO;
      }  // container gr-peer

      leaf connect-count {
        type uint32;
        description "ConnectCount";
      }

      leaf is-neighbor-up {
        type boolean;
        description "Is neighbor up";
      }

      leaf is-liveness-timer-running {
        type boolean;
        description
          "Is liveness timer running";
      }

      leaf liveness-timer-remaining-seconds {
        type uint32;
        description
          "Remaining time from liveness timer";
      }

      leaf is-recovery-timer-running {
        type boolean;
        description
          "Is recovery timer running";
      }

      leaf recovery-timer-remaining-seconds {
        type uint32;
        description
          "Recovery timer remining time";
      }

      leaf down-nbr-flap-count {
        type uint8;
        description
          "Count of back2back flaps";
      }

      leaf down-nbr-flags {
        type uint32;
        description "Flags";
      }

      leaf down-nbr-down-reason {
        type uint32;
        description
          "Session down reason code";
      }

      list down-nbr-interface {
        description
          "Interfaces bound to GR down Nbr";
        uses LDP-GR-DNBR-INTF-INFO;
      }  // list down-nbr-interface

      list down-nbr-address {
        description
          "Addresses bound to GR down Nbr";
        uses LDP-IP-ADDR-T-UNION;
      }  // list down-nbr-address
    }  // grouping LDP-GR-NBR-INFO

    grouping LDP-VRF-INFO {
      description "MPLS LDP VRF information";
      leaf name {
        type string;
        description "VRF Name";
      }

      leaf id {
        type uint32;
        description "VRF Id";
      }
    }  // grouping LDP-VRF-INFO

    grouping LDP-GR-GLOBAL-INFO {
      description
        "MPLS LDP Graceful Restart Information";
      container vrf {
        description "VRF information";
        uses LDP-VRF-INFO;
      }  // container vrf

      leaf is-forwarding-state-hold-timer-running {
        type boolean;
        description
          "Is graceful restart forwarding state hold timer
         running";
      }

      leaf forwarding-state-hold-timer-remaining-seconds {
        type uint32;
        units "second";
        description
          "Forwarding state hold timer remaining time in
         seconds";
      }

      list graceful-restartable-neighbor {
        description
          "Vector of graceful restart neighbor information";
        uses LDP-GR-NBR-INFO;
      }  // list graceful-restartable-neighbor
    }  // grouping LDP-GR-GLOBAL-INFO
  }  // submodule Cisco-IOS-XR-mpls-ldp-oper-sub1