module Cisco-IOS-XE-mpls-ldp-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XE-mpls-ldp-oper";

    prefix mpls-ldp-ios-xe-oper;

    import ietf-inet-types {
      prefix inet;
    }
    import ietf-yang-types {
      prefix yang;
    }
    import cisco-semver {
      prefix cisco-semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service

     Postal: 170 W Tasman Drive
     San Jose, CA 95134

     Tel: +1 1800 553-NETS

     E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG definitions
     for MPLS LDP operational data.
     Copyright (c) 2017-2019 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2019-11-01" {
      description "Initial revision";
      reference
        "1.0.0";

    }

    cisco-semver:module-version "1.0.0";

    typedef mpls-ldp-oper-status {
      type enumeration {
        enum "mpls-ldp-oper-status-unknown" {
          value 0;
          description "Unknown";
        }
        enum "mpls-ldp-oper-status-enabled" {
          value 1;
          description "Enabled";
        }
        enum "mpls-ldp-oper-status-disabled" {
          value 2;
          description "Disabled";
        }
      }
      description
        "Information of MPLS LDP operation status";
    }

    typedef hello-adjacency-type {
      type enumeration {
        enum "hello-adjacency-type-link" {
          value 0;
          description "Link adjacency";
        }
        enum "hello-adjacency-type-targeted" {
          value 1;
          description "Targeted adjacency";
        }
      }
      description "Hello adjacency type";
    }

    typedef session-role {
      type enumeration {
        enum "session-role-unknown" {
          value 0;
          description "Unknown";
        }
        enum "session-role-active" {
          value 1;
          description "Active";
        }
        enum "session-role-passive" {
          value 2;
          description "Passive";
        }
      }
      description "MPLS LDP session role";
    }

    typedef session-state {
      type enumeration {
        enum "session-state-non-existent" {
          value 0;
          description "Non-existent";
        }
        enum "session-state-initialized" {
          value 1;
          description "Initialized";
        }
        enum "session-state-open-received" {
          value 2;
          description "Open received";
        }
        enum "session-state-open-sent" {
          value 3;
          description "Open sent";
        }
        enum "session-state-operational" {
          value 4;
          description "Operational";
        }
      }
      description "MPLS LDP session state";
    }

    typedef label-distribution-method {
      type enumeration {
        enum "lbl-dist-method-dod" {
          value 0;
          description "Downstream on demand";
        }
        enum "lbl-dist-method-du" {
          value 1;
          description
            "Downstream unsolicited";
        }
      }
      description
        "Label distribution method";
    }

    typedef adj-state {
      type enumeration {
        enum "adj-state-ne" {
          value 0;
          description "Non-existent";
        }
        enum "adj-state-unsol-op-pd" {
          value 1;
          description
            "Unsolicited open pending";
        }
        enum "adj-state-def" {
          value 2;
          description "Deferred";
        }
        enum "adj-state-est" {
          value 3;
          description "Established";
        }
        enum "adj-state-wait-tib-exp" {
          value 4;
          description
            "Waiting for TIB expansion (peer index)";
        }
        enum "adj-state-dest" {
          value 5;
          description "Destroyed";
        }
      }
      description "LDP peer adjacency state";
    }

    typedef tcp-hash-type {
      type enumeration {
        enum "tcp-hash-type-none" {
          value 0;
          description
            "No hashing algorithm used for the TCP connection";
        }
        enum "tcp-hash-type-md5-password" {
          value 1;
          description
            "MD5 hashing on TCP connection, LDP gives TCP the password";
        }
        enum "tcp-hash-type-md5-keychain" {
          value 2;
          description
            "MD5 hashing on TCP connection, LDP gives TCP the keychain";
        }
        enum "tcp-hash-type-sha1" {
          value 3;
          description
            "SHA1 hashing algorithm used for the TCP connection";
        }
        enum "tcp-hash-type-tcp-ao" {
          value 4;
          description
            "TCP AO hashing algorithm used for the TCP connection";
        }
      }
      description "LDP peer tcp hash type";
    }

    typedef graceful-restart-down-neighbor-state {
      type enumeration {
        enum "gr-down-nbr-state-none" {
          value 0;
          description
            "None, state not available";
        }
        enum
          "gr-down-nbr-state-wait-connect" {
          value 1;
          description "Wait connect";
        }
        enum "gr-down-nbr-state-recovering" {
          value 2;
          description "Recovering";
        }
        enum "gr-down-nbr-state-defunct" {
          value 3;
          description "Defunct";
        }
      }
      description
        "LDP graceful restart down neighbor state";
    }

    typedef adj-flag {
      type bits {
        bit adj-flag-dir {
          position 0;
          description "Directed";
        }
        bit adj-flag-temp {
          position 1;
          description "Temporary";
        }
        bit adj-flag-force-down {
          position 2;
          description "Force down";
        }
        bit adj-flag-sess-up-wait {
          position 3;
          description
            "Waiting for session up";
        }
        bit adj-flag-ldp-hello {
          position 4;
          description "LDP hello";
        }
        bit adj-flag-tx {
          position 5;
          description "Transmitting";
        }
        bit adj-flag-need-route {
          position 6;
          description "Need route";
        }
        bit adj-flag-on-tx-q {
          position 7;
          description
            "On transmit working queue";
        }
        bit adj-flag-on-rx-q {
          position 8;
          description
            "On receive working queue";
        }
        bit adj-flag-pwd-chg-pd {
          position 9;
          description
            "Password change pending";
        }
        bit adj-flag-pwd-req {
          position 10;
          description "Password required";
        }
        bit adj-flag-intf-down {
          position 11;
          description "Interface down";
        }
        bit adj-flag-pwd-chg-ro-pd {
          position 12;
          description
            "Password change roll over pending";
        }
        bit adj-flag-exp-delayed {
          position 13;
          description "Expire delayed";
        }
        bit adj-flag-rd-blk {
          position 14;
          description "Read blocked";
        }
        bit adj-flag-rd-pdu {
          position 15;
          description "Reading PDU";
        }
      }
      description
        "MPLS LDP discovery adjacency flags";
    }

    typedef graceful-restart-neighbor-session-flag {
      type bits {
        bit gr-nbr-flag-need-mark {
          position 0;
          description "Need mark";
        }
        bit gr-nbr-flag-need-id-change {
          position 1;
          description
            "Need Identifier change";
        }
        bit gr-nbr-flag-need-delete {
          position 2;
          description
            "Needs deletion of the session";
        }
      }
      description
        "Graceful restart down neighbor session flags";
    }

    grouping local-label-binding {
      description "Local label binding";
      leaf label {
        type uint32;
        description
          "Local label value
         0 - 0xfffff   : Valid local label range
         (0xfffff + 2) : No local label is allocated for this prefix";
      }

      leaf withdrawn {
        type boolean;
        description "withdraw flag";
      }

      leaf wd-sent-to-peer {
        type boolean;
        description
          "Withdraw sent to peer flag";
      }

      leaf-list advertised-to {
        type string;
        ordered-by user;
        description "Peers advertised to";
      }
    }  // grouping local-label-binding

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

      leaf ldpid {
        type string;
        description "LDP Identifier";
      }

      leaf is-static {
        type boolean;
        description "Static label flag";
      }

      leaf checkpointed {
        type boolean;
        description "Checkpointed flag";
      }

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

      leaf recovered {
        type boolean;
        description "Recovered flag";
      }

      leaf entropy-label-capable {
        type boolean;
        description
          "Entropy label capable flag";
      }
    }  // grouping remote-label-binding

    grouping binding-fec-label {
      description "FEC label binding";
      leaf fec {
        type inet:ip-prefix;
        description
          "Forwarding Equivalent Class";
      }

      leaf revision {
        type uint16;
        description "Revision";
      }

      leaf checkpointed {
        type boolean;
        description "Checkpointed flag";
      }

      leaf entropy-label-capable {
        type boolean;
        description
          "Entropy label capable flag";
      }

      container local-binding {
        description "Local label binding";
        uses mpls-ldp-ios-xe-oper:local-label-binding;
      }  // container local-binding

      list remote-binding {
        description "Remote label bindings";
        uses mpls-ldp-ios-xe-oper:remote-label-binding;
      }  // list remote-binding
    }  // grouping binding-fec-label

    grouping capability {
      description "LDP capability state";
      leaf typed-wildcard {
        type boolean;
        description "Typed wildcard";
      }

      leaf iccp {
        type boolean;
        description
          "Inter-Chassis Communication Protocol";
      }

      leaf iccp-major-version {
        type uint8;
        description "ICCP major version";
      }

      leaf iccp-minor-version {
        type uint8;
        description "ICCP minor version";
      }

      leaf dynamic-announcement {
        type boolean;
        description "Dynamic announcement";
      }

      leaf mldp-p2mp {
        type boolean;
        description
          "mLDP Point-To-Multipoint";
      }

      leaf mldp-mp2mp {
        type boolean;
        description
          "mLDP Multipoint-To-Multipoint";
      }
    }  // grouping capability

    grouping graceful-restart {
      description
        "LDP graceful restart state";
      leaf enable {
        type boolean;
        description "Enable flag";
      }

      leaf reconnect-time {
        type uint32;
        units "seconds";
        description
          "Reconnect time in seconds";
      }

      leaf recover-time {
        type uint32;
        units "seconds";
        description
          "Recover time in seconds";
      }

      leaf forward-hold-time {
        type uint32;
        units "seconds";
        description
          "Forward hold time in seconds";
      }
    }  // grouping graceful-restart

    grouping hello-adjacency-key {
      description "LDP hello adjacency key";
      leaf adjacent-address {
        type inet:ip-address;
        description "Adjacency address";
      }

      leaf transport-address {
        type inet:ip-address;
        description "Transport address";
      }
    }  // grouping hello-adjacency-key

    grouping hello-adjacency {
      description
        "LDP hello adjacency information";
      leaf adjacent-ldpid {
        type string;
        description
          "Adjacent LDP Identifier";
      }

      leaf flag {
        type adj-flag;
        description
          "Flags (see: mpls ldp discovery adjacency flag)";
      }

      leaf targeted-passive {
        type boolean;
        description "Flag: targeted passive";
      }

      leaf hello-hold-time-adjacent {
        type uint16;
        units "seconds";
        description
          "Adjacent hello hold time in seconds";
      }

      leaf hello-hold-time-negotiated {
        type uint16;
        units "seconds";
        description
          "Negotiated hello hold time in seconds";
      }

      leaf hello-hold-time-remaining {
        type uint16;
        units "seconds";
        description
          "Remaining hello hold time in seconds";
      }

      leaf password-required {
        type boolean;
        description
          "Flag: Password required";
      }

      leaf password-pending {
        type uint16;
        description "Flag: Password pending";
      }

      leaf password-source {
        type uint32;
        description
          "Password source values
         * 0       : neighbor
           This indicates that the password for the neighbor is retrieved
           from the mpls ldp neighbor [vrf vrf-name] ip-address password [0 | 7] password command.
         * 1~32767 : password option number
           This number defines the order in which the access lists are
           evaluated in the determination of a neighbor password.
         * 32768   : fall back to MD5 password for LDP sessions with peers
         * 32769   : none i.e, No password is configured for this neighbor";
      }

      leaf nexthop {
        type inet:ip-address;
        description "Next-hop address";
      }

      leaf no-route {
        type boolean;
        description
          "Flag: no route to transport address";
      }

      leaf no-host-route {
        type boolean;
        description
          "Flag: no host route to transport address";
      }
    }  // grouping hello-adjacency

    grouping link-state {
      description
        "LDP hello discovery source state for linked adjacency";
      leaf igp-sync-enable {
        type boolean;
        description "Flag: IGP sync enabled";
      }

      leaf igp-sync-delay {
        type uint16;
        units "seconds";
        description
          "IGP sync delay in seconds";
      }
    }  // grouping link-state

    grouping targeted-state {
      description
        "LDP hello discovery source state for targeted adjacency";
      leaf hello-accept-enable {
        type boolean;
        description
          "Flag: hello accept enabled";
      }

      leaf hello-accept-neighbor-list {
        type string;
        description
          "LDP hello accept neighbor list";
      }
    }  // grouping targeted-state

    grouping discovery-source-key {
      description
        "LDP adjacency discovery source table key";
      leaf is-targeted-adjacency {
        type uint8;
        description
          "Flag: targeted adjacency";
      }

      leaf if-index {
        type uint32;
        description
          "interface index for link adjacency;
         value 0 for targeted adjacency";
      }
    }  // grouping discovery-source-key

    grouping discovery-source {
      description
        "LDP adjacency discovery source state";
      leaf hello-hold-time {
        type uint16;
        units "seconds";
        description
          "Hello hold time in seconds";
      }

      leaf hello-interval {
        type uint16;
        units "seconds";
        description
          "Hello interval in seconds";
      }

      leaf enable {
        type boolean;
        description "Flag: enable";
      }

      leaf transport-address {
        type inet:ip-address;
        description "Transport address";
      }

      list mpls-ldp-disc-hello-adj {
        key "adjacent-address transport-address";
        description "Hello adjacencies";
        uses mpls-ldp-ios-xe-oper:hello-adjacency-key;

        uses mpls-ldp-ios-xe-oper:hello-adjacency;
      }  // list mpls-ldp-disc-hello-adj

      choice type-choice {
        description "Hello adjacency type";
        container link-state {
          description
            "Link type adjacency state";
          uses mpls-ldp-ios-xe-oper:link-state;
        }  // container link-state
        container targeted-state {
          description
            "Targeted type adjacency state";
          uses mpls-ldp-ios-xe-oper:targeted-state;
        }  // container targeted-state
      }  // choice type-choice
    }  // grouping discovery-source

    grouping label-advertisement-mode {
      description
        "LDP label advertisement mode";
      leaf local {
        type label-distribution-method;
        description
          "Local label advertisement mode";
      }

      leaf negotiated {
        type label-distribution-method;
        description
          "Negotiated label advertisement mode";
      }
    }  // grouping label-advertisement-mode

    grouping peer-graceful-restart {
      description
        "LDP peer graceful restart state";
      leaf enable {
        type boolean;
        description "Enable flag";
      }

      leaf reconnect-time {
        type uint16;
        units "seconds";
        description
          "Reconnect time in seconds";
      }

      leaf recovery-time {
        type uint16;
        units "seconds";
        description
          "Recovery time in seconds";
      }
    }  // grouping peer-graceful-restart

    grouping session-hold-time {
      description
        "LDP peer session hold time state";
      leaf negotiated {
        type uint16;
        units "seconds";
        description
          "Negotiated session hold time in seconds";
      }
    }  // grouping session-hold-time

    grouping tcp-connection {
      description
        "LDP peer session TCP connection state";
      leaf local-address {
        type inet:ip-address;
        description "Local address";
      }

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

      leaf remote-address {
        type inet:ip-address;
        description "Remote address";
      }

      leaf remote-port {
        type uint16;
        description "Remote port";
      }
    }  // grouping tcp-connection

    grouping peer-events {
      description "LDP peer events state";
      leaf total-messages {
        type uint64;
        description "Total messages";
      }
    }  // grouping peer-events

    grouping peer-statistics {
      description
        "LDP peer statistic counters";
      container sent {
        description "Sent peer events";
        uses mpls-ldp-ios-xe-oper:peer-events;
      }  // container sent

      container received {
        description "Received peer events";
        uses mpls-ldp-ios-xe-oper:peer-events;
      }  // container received

      leaf nsr-in-lbl-req-rec-created {
        type uint32;
        description
          "Protocol state counter: NSR incoming label request record created";
      }

      leaf nsr-in-lbl-req-rec-freed {
        type uint32;
        description
          "Protocol state counter: NSR incoming label request record freed";
      }

      leaf nsr-in-lbl-wd-rec-created {
        type uint32;
        description
          "protocol state counter: NSR incoming label withdraw record created";
      }

      leaf nsr-in-lbl-wd-rec-freed {
        type uint32;
        description
          "protocol state counter: NSR incoming label withdraw record freed";
      }

      leaf nsr-lcl-addr-wd-rec-created {
        type uint32;
        description
          "Protocol state counter: NSR local address withdraw record created";
      }

      leaf nsr-lcl-addr-wd-rec-freed {
        type uint32;
        description
          "Protocol state counter: NSR local address withdraw record freed";
      }

      leaf adj-last-addr-rev-sent {
        type uint64;
        description
          "adjacent last address revision sent";
      }
    }  // grouping peer-statistics

    grouping peer-discovery-source {
      description
        "LDP peer discovery source";
      leaf is-targeted-adjacency {
        type boolean;
        description
          "Flag: targeted adjacency";
      }

      leaf if-index {
        type uint32;
        description
          "Interface index for link adjacency, 0 for targeted adjacency";
      }

      leaf adjacent-address {
        type inet:ip-address;
        description "Adjacent address";
      }

      leaf transport-address {
        type inet:ip-address;
        description "Transport address";
      }
    }  // grouping peer-discovery-source

    grouping peer {
      description "LDP peer state";
      leaf peer-id {
        type string;
        description "Peer LDP identifier";
      }

      leaf admin-down {
        type boolean;
        description "Flag: admin down";
      }

      leaf state {
        type adj-state;
        description "adjacency state";
      }

      leaf session-protocol-version {
        type uint32;
        description
          "Session protocol version";
      }

      container capability-sent {
        description "Capability sent";
        uses mpls-ldp-ios-xe-oper:capability;
      }  // container capability-sent

      container capability-received {
        description "Capability received";
        uses mpls-ldp-ios-xe-oper:capability;
      }  // container capability-received

      leaf sess-auth-type {
        type tcp-hash-type;
        description
          "Session authentication type";
      }

      container graceful-restart {
        description "Graceful restart state";
        uses mpls-ldp-ios-xe-oper:peer-graceful-restart;
      }  // container graceful-restart

      leaf nsr-ready {
        type boolean;
        description "Flag: NSR ready";
      }

      leaf sess-ka-hold-time {
        type uint16;
        units "seconds";
        description
          "Session keepalive hold time in seconds";
      }

      leaf sess-ka-interval {
        type uint16;
        units "seconds";
        description
          "Session keepalive hold interval in seconds";
      }

      container advertisement-mode {
        description
          "Label advertisement mode";
        uses mpls-ldp-ios-xe-oper:label-advertisement-mode;
      }  // container advertisement-mode

      container session-hold-time {
        description
          "Session hold time in seconds";
        uses mpls-ldp-ios-xe-oper:session-hold-time;
      }  // container session-hold-time

      leaf session-protection-duration {
        type uint16;
        units "seconds";
        description
          "Session protection duration in seconds";
      }

      leaf session-protection-acl {
        type string;
        description
          "Session protection ACL name";
      }

      leaf session-state {
        type session-state;
        description "Session state";
      }

      leaf session-role {
        type session-role;
        description "Session role";
      }

      container tcp-connection {
        description "TCP connection";
        uses mpls-ldp-ios-xe-oper:tcp-connection;
      }  // container tcp-connection

      list discovery-sources {
        description "Discovery sources";
        uses mpls-ldp-ios-xe-oper:peer-discovery-source;
      }  // list discovery-sources

      leaf establish-time {
        type yang:date-and-time;
        description "Establish time";
      }

      leaf-list address-bound {
        type inet:ip-address;
        ordered-by user;
        description "Bound addresses";
      }

      leaf password-required {
        type boolean;
        description
          "Flag: password required";
      }

      leaf password-change-pending {
        type boolean;
        description
          "Flag: password change pending";
      }

      leaf password-rollover-pending {
        type boolean;
        description
          "Flag: password rollover pending";
      }

      leaf password-source {
        type uint32;
        description
          "Password source values
         * 0       : neighbor
           This indicates that the password for the neighbor is retrieved
           from the mpls ldp neighbor [vrf vrf-name] ip-address password [0 | 7] password command.
         * 1~32767 : password option number
           This number defines the order in which the access lists are
           evaluated in the determination of a neighbor password.
         * 32768   : fall back to MD5 password for LDP sessions with peers
         * 32769   : none i.e, No password is configured for this neighbor";
      }

      leaf is-keychain {
        type boolean;
        description "Flag: keychain";
      }

      leaf keychain-name {
        type string;
        description "Keychain name";
      }

      container statistics {
        description "Peer statistics";
        uses mpls-ldp-ios-xe-oper:peer-statistics;
      }  // container statistics
    }  // grouping peer

    grouping graceful-restart-neighbor-session-id {
      description
        "Graceful restart down neighbor session Identifier";
      leaf ldpid {
        type string;
        description "LDP Identifier";
      }

      leaf instance {
        type uint16;
        description
          "Instance Identifier
         * 0        : chassis-wide TDP Identifier
         * non-zero : Not chassis-wide TDP Identifier (i.e,for a ATM interface)";
      }

      leaf flags {
        type graceful-restart-neighbor-session-flag;
        description
          "Flag value,
         0x01 : Request bindings marking
         0x02 : Request bindings update if a new LDP ID is being used
         0x04 : Request bindings deletion";
      }
    }  // grouping graceful-restart-neighbor-session-id

    grouping graceful-restart-down-neighbor {
      description
        "Graceful restart down neighbor data";
      leaf peer-id {
        type string;
        description "Peer LDP Identifier";
      }

      container old-session {
        description "Old session Identifier";
        uses mpls-ldp-ios-xe-oper:graceful-restart-neighbor-session-id;
      }  // container old-session

      container new-session {
        description "New session Identifier";
        uses mpls-ldp-ios-xe-oper:graceful-restart-neighbor-session-id;
      }  // container new-session

      list session-history {
        description "Session history";
        uses mpls-ldp-ios-xe-oper:graceful-restart-neighbor-session-id;
      }  // list session-history

      leaf num-restarts {
        type uint8;
        description "Number of restarts";
      }

      leaf listed {
        type boolean;
        description
          "Flag: New record created in GR down neighbor
         database";
      }

      leaf on-task-queue {
        type boolean;
        description
          "Flag: New record added to the GR down neighbor
         bindings management task queue";
      }

      leaf down-neighbor-state {
        type graceful-restart-down-neighbor-state;
        description "Down neighbor state";
      }

      leaf sso-created {
        type boolean;
        description
          "Flag: Stateful Switch Over created";
      }

      leaf-list address-list {
        type inet:ip-address;
        ordered-by user;
        description "Address list";
      }

      leaf reconnect-time-left {
        type uint16;
        units "seconds";
        description
          "Reconnect time left in seconds";
      }

      leaf recovery-time-left {
        type uint16;
        units "seconds";
        description
          "Recover time left in seconds";
      }
    }  // grouping graceful-restart-down-neighbor

    grouping ldp-state {
      description "MPLS LDP state";
      leaf table-id {
        type uint64;
        description
          "Routing table Identifier";
      }

      leaf oper-status {
        type mpls-ldp-oper-status;
        description "Operational status";
      }

      container capability {
        description
          "Capabilities information";
        uses mpls-ldp-ios-xe-oper:capability;
      }  // container capability

      container graceful-restart {
        description
          "Graceful restart information";
        uses mpls-ldp-ios-xe-oper:graceful-restart;
      }  // container graceful-restart

      leaf igp-sync-hold-down-time {
        type uint32;
        units "seconds";
        description
          "IGP sync hold down time in seconds";
      }

      leaf path-vector-limit {
        type uint32;
        description "Path vector limit";
      }

      leaf hop-count-limit {
        type uint32;
        description "Hop count limit";
      }

      leaf enable {
        type boolean;
        description "Enable flag";
      }

      leaf transport-address {
        type inet:ip-address;
        description "Transport address";
      }

      list mpls-ldp-binding-fec-lbl {
        key "fec";
        description "FEC label binding";
        uses mpls-ldp-ios-xe-oper:binding-fec-label;
      }  // list mpls-ldp-binding-fec-lbl

      leaf hello-hold-time {
        type uint16;
        units "seconds";
        description
          "Discovery hello hold time in seconds";
      }

      leaf hello-interval {
        type uint16;
        units "seconds";
        description
          "Discovery hello interval in seconds";
      }

      leaf ldpid {
        type string;
        description "LDP identifier";
      }

      list mpls-ldp-disc-src {
        key "is-targeted-adjacency if-index";
        description "Discovery sources";
        uses mpls-ldp-ios-xe-oper:discovery-source-key;

        uses mpls-ldp-ios-xe-oper:discovery-source;
      }  // list mpls-ldp-disc-src

      leaf sess-ka-hold-time {
        type uint16;
        units "seconds";
        description
          "Session keepalive hold time in seconds";
      }

      leaf sess-ka-interval {
        type uint16;
        units "seconds";
        description
          "Session keepalive interval in seconds";
      }

      list mpls-ldp-peer {
        key "peer-id";
        description "MPLS LDP peers";
        uses mpls-ldp-ios-xe-oper:peer;
      }  // list mpls-ldp-peer

      list mpls-ldp-gr-down-nbr {
        key "peer-id";
        description
          "MPLS LDP Graceful restart down neighbors";
        uses mpls-ldp-ios-xe-oper:graceful-restart-down-neighbor;
      }  // list mpls-ldp-gr-down-nbr

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

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

      leaf disc-num-link-adj {
        type uint32;
        description
          "Number of LDP Link Adjacencies";
      }

      leaf disc-num-tgt-adj {
        type uint32;
        description
          "Number of LDP Targeted Adjacencies";
      }

      leaf disc-num-bad-src-addr {
        type uint32;
        description
          "Number of LDP errors with Bad Source address";
      }

      leaf disc-num-bad-hello-pdu {
        type uint32;
        description
          "Number of LDP errors with Bad Hello PDUs";
      }

      leaf disc-num-bad-xport-addr {
        type uint32;
        description
          "Number of LDP errors with Bad Transport address";
      }

      leaf disc-num-same-router-id {
        type uint32;
        description
          "Number of LDP errors with same router id";
      }

      leaf disc-num-wrong-router-id {
        type uint32;
        description
          "Number of LDP errors with wrong router id";
      }
    }  // grouping ldp-state

    container mpls-ldp-oper-data {
      config false;
      description
        "MPLS LDP operational data";
      list mpls-ldp-state {
        key "table-id";
        description
          "MPLS LDP state information";
        uses mpls-ldp-ios-xe-oper:ldp-state;
      }  // list mpls-ldp-state
    }  // container mpls-ldp-oper-data
  }  // module Cisco-IOS-XE-mpls-ldp-oper