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";
    }

    container mpls-ldp-oper-data {
      config false;
      description
        "MPLS LDP operational data";
      list mpls-ldp-state {
        key "table-id";
        description
          "MPLS LDP state information";
        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";
          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";
          }
        }  // container capability

        container graceful-restart {
          description
            "Graceful restart information";
          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";
          }
        }  // 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";
          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";
            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";
            }
          }  // container local-binding

          list remote-binding {
            description
              "Remote label bindings";
            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";
            }
          }  // list remote-binding
        }  // 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";
          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";
          }

          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";
            leaf adjacent-address {
              type inet:ip-address;
              description
                "Adjacency address";
            }

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

            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";
            }
          }  // list mpls-ldp-disc-hello-adj

          choice type-choice {
            description
              "Hello adjacency type";
            container link-state {
              description
                "Link type adjacency state";
              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";
              }
            }  // container link-state
            container targeted-state {
              description
                "Targeted type adjacency state";
              leaf hello-accept-enable {
                type boolean;
                description
                  "Flag: hello accept enabled";
              }

              leaf hello-accept-neighbor-list {
                type string;
                description
                  "LDP hello accept neighbor list";
              }
            }  // container targeted-state
          }  // choice type-choice
        }  // 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";
          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";
            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";
            }
          }  // container capability-sent

          container capability-received {
            description
              "Capability received";
            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";
            }
          }  // container capability-received

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

          container graceful-restart {
            description
              "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";
            }
          }  // 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";
            leaf local {
              type label-distribution-method;
              description
                "Local label advertisement mode";
            }

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

          container session-hold-time {
            description
              "Session hold time in seconds";
            leaf negotiated {
              type uint16;
              units "seconds";
              description
                "Negotiated session hold time in seconds";
            }
          }  // 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";
            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";
            }
          }  // container tcp-connection

          list discovery-sources {
            description "Discovery sources";
            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";
            }
          }  // 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";
            container sent {
              description "Sent peer events";
              leaf total-messages {
                type uint64;
                description "Total messages";
              }
            }  // container sent

            container received {
              description
                "Received peer events";
              leaf total-messages {
                type uint64;
                description "Total messages";
              }
            }  // 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";
            }
          }  // container statistics
        }  // list mpls-ldp-peer

        list mpls-ldp-gr-down-nbr {
          key "peer-id";
          description
            "MPLS LDP Graceful restart down neighbors";
          leaf peer-id {
            type string;
            description
              "Peer LDP Identifier";
          }

          container old-session {
            description
              "Old 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";
            }
          }  // container old-session

          container new-session {
            description
              "New 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";
            }
          }  // container new-session

          list session-history {
            description "Session history";
            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";
            }
          }  // 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";
          }
        }  // 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";
        }
      }  // list mpls-ldp-state
    }  // container mpls-ldp-oper-data
  }  // module Cisco-IOS-XE-mpls-ldp-oper