module Cisco-IOS-XR-um-mpls-ldp-cfg {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-um-mpls-ldp-cfg";

    prefix um-mpls-ldp-cfg;

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

    organization "Cisco Systems, Inc.";

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

    description
      "This module contains a collection of YANG definitions
     for Cisco IOS-XR mpls-ldp package configuration.
     
     This YANG module augments the
     modules with configuration data.
     
     Copyright (c) 2019-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-01-29" {
      description
        "Add enable container under recursive-fec container
       2021-01-28
         Added cisco-support task yang nodes
       2020-12-08
         Removed cisco-support yang nodes
       2020-07-10
         Added when statement to redistribute to show it's only for ipv4";
    }

    revision "2020-05-29" {
      description
        "Changed description for sac";
    }

    revision "2019-12-10" {
      description
        "Corrected must statement definition for password/encrypted,disable";
    }

    revision "2019-10-10" {
      description
        "Moved trap augments into Cisco-IOS-XR-um-traps-mpls-ldp-cfg.";
    }

    revision "2019-09-25" {
      description
        "Changed the list node name access-list to access-lists.";
    }

    revision "2019-06-10" {
      description
        "Establish semantic version baseline.";
    }

    revision "2019-03-30" {
      description "Initial version";
    }

    semver:module-version "2.0.0";
    semver:module-version "2.0.0";

    container mpls {
      description
        "Global MPLS configuration subcommands";
      container ldp {
        presence
          "Indicates a ldp node is configured.";
        description
          "Label Distribution Protocol";
        container mldp {
          presence
            "Indicates a mldp node is configured.";
          description
            "Configure mLDP parameters";
          container logging {
            description
              "MLDP logging commands";
            container notifications {
              presence
                "Indicates a notifications node is configured.";
              description
                "MLDP logging notifications";
            }  // container notifications

            container internal {
              presence
                "Indicates a internal node is configured.";
              description
                "MLDP logging internal";
            }  // container internal
          }  // container logging

          container vrfs {
            description
              "Configure VRF parameters";
            list vrf {
              key "vrf-name";
              description
                "Configure VRF parameters";
              leaf vrf-name {
                type xr:Cisco-ios-xr-string {
                  length "1..1024";
                }
                description
                  "Configure VRF parameters";
              }

              container address-families {
                description
                  "Configure Address Family and its parameters";
                list address-family {
                  key "af-name";
                  description
                    "Configure Address Family and its parameters";
                  leaf af-name {
                    type enumeration {
                      enum "ipv4" {
                        value 4;
                        description "IPv4";
                      }
                    }
                    description
                      "Configure Address Family and its parameters";
                  }

                  container statics {
                    description
                      "Static mLDP LSP";
                    list static {
                      key "lsp-address";
                      description
                        "Staic mLDP LSP";
                      leaf lsp-address {
                        type inet:ipv4-address-no-zone;
                        description
                          "LSP address";
                      }

                      leaf p2mp {
                        type uint32 {
                          range "1..1000";
                        }
                        description
                          "P2MP LSP";
                      }

                      leaf mp2mp {
                        type uint32 {
                          range "1..1000";
                        }
                        description
                          "MP2MP LSP";
                      }
                    }  // list static
                  }  // container statics

                  container make-before-break {
                    description
                      "Make Before Break";
                    container delay {
                      presence
                        "Indicates a delay node is configured.";
                      description
                        "MBB delay";
                      leaf forwarding-delay {
                        type uint32 {
                          range "0..600";
                        }
                        mandatory true;
                        description
                          "MBB delay";
                      }

                      leaf delete-delay {
                        type uint32 {
                          range "0..60";
                        }
                        default "0";
                        description
                          "Delete delay in seconds";
                      }
                    }  // container delay

                    leaf route-policy {
                      type xr:Route-policy-name;
                      description
                        "Route policy";
                    }
                  }  // container make-before-break

                  container mofrr {
                    presence
                      "Indicates a mofrr node is configured.";
                    description
                      "MLDP MoFRR support";
                    leaf route-policy {
                      type xr:Route-policy-name;
                      description
                        "Route policy";
                    }
                  }  // container mofrr

                  container neighbors {
                    description
                      "MLDP neighbor commands";
                    container in {
                      description
                        "Inbound route policy";
                      leaf route-policy {
                        type xr:Route-policy-name;
                        description
                          "Route policy";
                      }
                    }  // container in

                    container out {
                      description
                        "Inbound route policy";
                      leaf route-policy {
                        type xr:Route-policy-name;
                        description
                          "Route policy";
                      }
                    }  // container out

                    list neighbor {
                      must
                        "in or out or (in and out)";
                      key "neighbor-address";
                      description
                        "MLDP neighbor commands";
                      leaf neighbor-address {
                        type inet:ipv4-address-no-zone;
                        description
                          "configure this node";
                      }

                      container in {
                        description
                          "Inbound route policy";
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy";
                        }
                      }  // container in

                      container out {
                        description
                          "Inbound route policy";
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy";
                        }
                      }  // container out
                    }  // list neighbor
                  }  // container neighbors

                  container forwarding {
                    description
                      "Forwarding commands";
                    container recursive {
                      presence
                        "Indicates a recursive node is configured.";
                      description
                        "Enable recursive forwarding";
                      leaf route-policy {
                        type xr:Route-policy-name;
                        description
                          "Route policy";
                      }
                    }  // container recursive
                  }  // container forwarding

                  container rib {
                    description
                      "RIB commands";
                    container unicast-always {
                      presence
                        "Indicates a unicast-always node is configured.";
                      description
                        "Always use unicast table for root lookup";
                    }  // container unicast-always
                  }  // container rib
                }  // list address-family
              }  // container address-families
            }  // list vrf
          }  // container vrfs

          container address-families {
            description
              "Configure Address Family and its parameters";
            list address-family {
              key "af-name";
              description
                "Configure Address Family and its parameters";
              leaf af-name {
                type enumeration {
                  enum "ipv4" {
                    value 4;
                    description "IPv4";
                  }
                }
                description
                  "Configure Address Family and its parameters";
              }

              container statics {
                description
                  "Static mLDP LSP";
                list static {
                  key "lsp-address";
                  description
                    "Static mLDP LSP";
                  leaf lsp-address {
                    type inet:ipv4-address-no-zone;
                    description
                      "LSP address";
                  }

                  leaf p2mp {
                    type uint32 {
                      range "1..1000";
                    }
                    description "P2MP LSP";
                  }

                  leaf mp2mp {
                    type uint32 {
                      range "1..1000";
                    }
                    description "MP2MP LSP";
                  }
                }  // list static
              }  // container statics

              container make-before-break {
                description
                  "Make Before Break";
                container delay {
                  presence
                    "Indicates a delay node is configured.";
                  description "MBB delay";
                  leaf forwarding-delay {
                    type uint32 {
                      range "0..600";
                    }
                    mandatory true;
                    description "MBB delay";
                  }

                  leaf delete-delay {
                    type uint32 {
                      range "0..60";
                    }
                    default "0";
                    description
                      "Delete delay in seconds";
                  }
                }  // container delay

                leaf route-policy {
                  type xr:Route-policy-name;
                  description "Route policy";
                }
              }  // container make-before-break

              container carrier-supporting-carrier {
                presence
                  "Indicates a carrier-supporting-carrier node is configured.";
                description
                  "MLDP CSC support";
              }  // container carrier-supporting-carrier

              container mofrr {
                presence
                  "Indicates a mofrr node is configured.";
                description
                  "MLDP MoFRR support";
                leaf route-policy {
                  type xr:Route-policy-name;
                  description "Route policy";
                }
              }  // container mofrr

              container recursive-fec {
                description
                  "MLDP Recursive FEC support";
                container enable {
                  presence
                    "Indicates a enable node is configured.";
                  description
                    "MLDP Recursive FEC enable";
                }  // container enable

                leaf route-policy {
                  type xr:Route-policy-name;
                  description "Route policy";
                }
              }  // container recursive-fec

              container neighbors {
                description
                  "MLDP neighbor commands";
                container in {
                  description
                    "Inbound route policy";
                  leaf route-policy {
                    type xr:Route-policy-name;
                    description
                      "Route policy";
                  }
                }  // container in

                container out {
                  description
                    "Inbound route policy";
                  leaf route-policy {
                    type xr:Route-policy-name;
                    description
                      "Route policy";
                  }
                }  // container out

                list neighbor {
                  must
                    "in or out or (in and out)";
                  key "neighbor-address";
                  description
                    "configure this node";
                  leaf neighbor-address {
                    type inet:ipv4-address-no-zone;
                    description
                      "configure this node";
                  }

                  container in {
                    description
                      "Inbound route policy";
                    leaf route-policy {
                      type xr:Route-policy-name;
                      description
                        "Route policy";
                    }
                  }  // container in

                  container out {
                    description
                      "Inbound route policy";
                    leaf route-policy {
                      type xr:Route-policy-name;
                      description
                        "Route policy";
                    }
                  }  // container out
                }  // list neighbor
              }  // container neighbors

              container forwarding {
                description
                  "Forwarding commands";
                container recursive {
                  presence
                    "Indicates a recursive node is configured.";
                  description
                    "Enable recursive forwarding";
                  leaf route-policy {
                    type xr:Route-policy-name;
                    description
                      "Route policy";
                  }
                }  // container recursive
              }  // container forwarding

              container rib {
                description "RIB commands";
                container unicast-always {
                  presence
                    "Indicates a unicast-always node is configured.";
                  description
                    "Always use unicast table for root lookup";
                }  // container unicast-always
              }  // container rib
            }  // list address-family
          }  // container address-families
        }  // container mldp

        container vrfs {
          description
            "Configure VRF parameters";
          list vrf {
            key "vrf-name";
            description
              "Configure VRF parameters";
            leaf vrf-name {
              type xr:Cisco-ios-xr-string {
                length "1..1024";
              }
              description
                "Configure VRF parameters";
            }

            leaf router-id {
              type inet:ipv4-address-no-zone;
              description
                "Configure router Id";
            }

            container session {
              description
                "Configure session parameters";
              container downstream-on-demand {
                description
                  "Downstream on demand label advertisment mode";
                leaf with {
                  type string {
                    length "1..1024";
                  }
                  description
                    "Access list of LDP Peers";
                }
              }  // container downstream-on-demand
            }  // container session

            container graceful-restart {
              description
                "Configure graceful restart feature";
              container helper-peer {
                description
                  "Configure parameters related to GR peer(s) operating in helper mode";
                container maintain-on-local-reset {
                  description
                    "Maintain the state of a GR peer upon a local reset";
                  leaf for {
                    type string {
                      length "1..32";
                    }
                    description
                      "Access list of LDP Peers";
                  }
                }  // container maintain-on-local-reset
              }  // container helper-peer
            }  // container graceful-restart

            container neighbors {
              description
                "Configure neighbor parameters";
              container password {
                description
                  "Configure password for MD5 authentication for all neighbors";
                leaf encrypted {
                  type xr:Proprietary-password;
                  description
                    "Specifies an ENCRYPTED password will follow";
                }
              }  // container password

              list neighbor {
                key "neighbor-address label-space-id";
                description "neighbor";
                leaf neighbor-address {
                  type inet:ipv4-address-no-zone;
                  description
                    "configure this node";
                }

                leaf label-space-id {
                  type uint32 {
                    range "0";
                  }
                  description
                    "Label Space Id of neighbor";
                }

                container password {
                  description
                    "Configure password for MD5 authentication";
                  leaf encrypted {
                    type xr:Proprietary-password;
                    must "not(../disable)";
                    description
                      "Specifies an ENCRYPTED password will follow";
                  }

                  container disable {
                    must "not(../encrypted)";
                    presence
                      "Indicates a disable node is configured.";
                    description
                      "Disables the global password from this neighbor";
                  }  // container disable
                }  // container password
              }  // list neighbor
            }  // container neighbors

            container address-family {
              description
                "Configure Address Family and its parameters";
              container ipv4 {
                presence
                  "Indicates a ipv4 node is configured.";
                description "IPv4";
                container discovery {
                  description
                    "Configure discovery parameters";
                  container transport-address {
                    presence
                      "Indicates a transport-address node is configured.";
                    description
                      "Specify transport address for TCP connection";
                    leaf ip-address {
                      type inet:ipv4-address-no-zone;
                      mandatory true;
                      description
                        "IP address to be used as transport address";
                    }
                  }  // container transport-address
                }  // container discovery

                container label {
                  description
                    "Configure label control and policies";
                  container local {
                    description
                      "Configure local label control and policies";
                    container allocate {
                      description
                        "Configure label allocation control";
                      container for {
                        description
                          "Limit label allocation to a set of prefixes";
                        leaf ip-access-list {
                          type string {
                            length "1..1024";
                          }
                          must
                            "not(../host-routes)";
                          description
                            "IP access-list";
                        }

                        container host-routes {
                          must
                            "not(../ip-access-list)";
                          presence
                            "Indicates a host-routes node is configured.";
                          description
                            "Allocate label for host routes only";
                        }  // container host-routes
                      }  // container for
                    }  // container allocate

                    container default-route {
                      presence
                        "Indicates a default-route node is configured.";
                      description
                        "Enable MPLS forwarding for default route";
                    }  // container default-route

                    container implicit-null-override {
                      description
                        "Configure use of implicit-null local label for non-egress prefixes";
                      leaf for {
                        type string {
                          length "1..32";
                        }
                        description
                          "Limit implicit-null label use to a set of prefixes";
                      }
                    }  // container implicit-null-override

                    container advertise {
                      description
                        "Configure outbound label advertisement control";
                      container explicit-null {
                        must
                          "not(for and to)";
                        presence
                          "Indicates a explicit-null node is configured.";
                        description
                          "Configure explicit-null advertisement";
                        container for {
                          presence
                            "Indicates a for node is configured.";
                          description
                            "IP Access-list specifying controls on destination prefixes";
                          leaf access-list {
                            type string {
                              length
                                "1..1024";
                            }
                            mandatory true;
                            description
                              "IP Access-list specifying controls on destination prefixes";
                          }

                          container to {
                            presence
                              "Indicates a to node is configured.";
                            description
                              "IP Access-list specifying controls on LDP Peers";
                            leaf access-list {
                              type string {
                                length
                                  "1..1024";
                              }
                              mandatory
                                true;
                              description
                                "IP Access-list specifying controls on LDP Peers";
                            }
                          }  // container to
                        }  // container for

                        container to {
                          presence
                            "Indicates a to node is configured.";
                          description
                            "IP Access-list specifying controls on LDP Peers";
                          leaf access-list {
                            type string {
                              length
                                "1..1024";
                            }
                            mandatory true;
                            description
                              "IP Access-list specifying controls on LDP Peers";
                          }
                        }  // container to
                      }  // container explicit-null

                      container to {
                        description
                          "Peer centric outbound label filtering";
                        list neighbor {
                          key "neighbor-address label-space-id";
                          description
                            "neighbor";
                          leaf neighbor-address {
                            type inet:ipv4-address-no-zone;
                            description
                              "neighbor address";
                          }

                          leaf label-space-id {
                            type uint32 {
                              range "0";
                            }
                            description
                              "Label Space Id of neighbor";
                          }

                          leaf for {
                            type string {
                              length "1..32";
                            }
                            mandatory true;
                            description
                              "IP access-list for prefixes to be sent";
                          }
                        }  // list neighbor
                      }  // container to

                      container interfaces {
                        description
                          "Advertise interface host address";
                        list interface {
                          key "interface-name";
                          description
                            "Advertise interface host address";
                          leaf interface-name {
                            type xr:Interface-name;
                            description
                              "Advertise interface host address";
                          }
                        }  // list interface
                      }  // container interfaces

                      container disable {
                        presence
                          "Indicates a disable node is configured.";
                        description
                          "Disable label advertisement to all peers for all prefixes";
                      }  // container disable
                    }  // container advertise
                  }  // container local

                  container remote {
                    description
                      "Configure remote/peer label control and policies";
                    container accept {
                      description
                        "Configure inbound label acceptance control";
                      container from {
                        description
                          "Neighbor from whom to accept label advertisement";
                        list neighbor {
                          key "neighbor-address label-space-id";
                          description
                            "Neighbor from whom to accept label advertisement";
                          leaf neighbor-address {
                            type inet:ipv4-address-no-zone;
                            description
                              "Neighbor from whom to accept label advertisement";
                          }

                          leaf label-space-id {
                            type uint32 {
                              range "0";
                            }
                            description
                              "Label Space Id of neighbor";
                          }

                          leaf for {
                            type string {
                              length "1..32";
                            }
                            description
                              "IP access-list for destination prefixes";
                          }
                        }  // list neighbor
                      }  // container from
                    }  // container accept
                  }  // container remote
                }  // container label
              }  // container ipv4
            }  // container address-family

            container interfaces {
              description
                "Enable LDP on an interface and enter interface submode";
              list interface {
                key "interface-name";
                description
                  "Enable LDP on an interface and enter interface submode";
                leaf interface-name {
                  type xr:Interface-name;
                  description
                    "Enable LDP on an interface and enter interface submode";
                }

                container address-family {
                  description
                    "Configure Address Family and its parameters";
                  container ipv4 {
                    presence
                      "Indicates a ipv4 node is configured.";
                    description "IPv4";
                    container discovery {
                      description
                        "Configure discovery parameters";
                      container transport-address {
                        must
                          "(interface and not(ip-address)) or (ip-address and not(interface))";
                        presence
                          "Indicates a transport-address node is configured.";
                        description
                          "Specify interface LDP transport address";
                        container interface {
                          presence
                            "Indicates a interface node is configured.";
                          description
                            "Use this interface address as transport address";
                        }  // container interface

                        leaf ip-address {
                          type inet:ipv4-address-no-zone;
                          description
                            "IP address to be used as transport address";
                        }
                      }  // container transport-address
                    }  // container discovery
                  }  // container ipv4
                }  // container address-family
              }  // list interface
            }  // container interfaces
          }  // list vrf
        }  // container vrfs

        container ltrace-buffer {
          description
            "Configure ltrace buffer file";
          leaf multiplier {
            type uint32 {
              range "1..5";
            }
            description
              "Ltrace buffer file size multiplier";
          }
        }  // container ltrace-buffer

        container default-vrf {
          description
            "Control default VRF behaviour";
          container implicit-ipv4 {
            description
              "Control Implicit enabling of IPv4 address family behavior";
            container disable {
              presence
                "Indicates a disable node is configured.";
              description
                "Disable the implicit enabling for IPv4 address family ";
            }  // container disable
          }  // container implicit-ipv4
        }  // container default-vrf

        container session {
          description
            "Configure session parameters";
          container backoff {
            presence
              "Indicates a backoff node is configured.";
            description
              "Configure session backoff parameters";
            leaf backoff-time {
              type uint32 {
                range "5..2147483";
              }
              mandatory true;
              description
                "Configure session backoff parameters";
            }

            leaf maximum-session-backoff-time {
              type uint32 {
                range "5..2147483";
              }
              mandatory true;
              description
                "Maximum session backoff time (seconds)";
            }
          }  // container backoff

          leaf holdtime {
            type uint32 {
              range "15..65535";
            }
            description
              "Configure session holdtime";
          }

          container downstream-on-demand {
            description
              "Downstream on demand label advertisment mode";
            leaf with {
              type string {
                length "1..1024";
              }
              description
                "Access list of LDP Peers";
            }
          }  // container downstream-on-demand

          container protection {
            presence
              "Indicates a protection node is configured.";
            description
              "Configure session protection parameters";
            container for {
              must "not(../duration)";
              presence
                "Indicates a for node is configured.";
              description
                "IP Access list to specify LDP Peers";
              leaf for-access-list {
                type string {
                  length "1..1024";
                }
                mandatory true;
                description
                  "IP Access list to specify LDP Peers";
              }

              container duration {
                description
                  "Session protection duration after loss of link discovery";
                leaf holdup-time {
                  type uint32 {
                    range "30..2147483";
                  }
                  must "not(../infinite)";
                  description
                    "Holdup time in seconds";
                }

                container infinite {
                  must "not(../holdup-time)";
                  presence
                    "Indicates a infinite node is configured.";
                  description
                    "Protect session forever after loss of link discovery";
                }  // container infinite
              }  // container duration
            }  // container for

            container duration {
              must
                "not(../for) and (holdup-time or infinite)";
              presence
                "Indicates a duration node is configured.";
              description
                "Session protection duration after loss of link discovery";
              leaf holdup-time {
                type uint32 {
                  range "30..2147483";
                }
                must "not(../infinite)";
                description
                  "Holdup time in seconds";
              }

              container infinite {
                must "not(../holdup-time)";
                presence
                  "Indicates a infinite node is configured.";
                description
                  "Protect session forever after loss of link discovery";
              }  // container infinite
            }  // container duration
          }  // container protection
        }  // container session

        container nsr {
          presence
            "Indicates a nsr node is configured.";
          description
            "Configure Non-Stop Routing";
        }  // container nsr

        container entropy-label {
          presence
            "Indicates a entropy-label node is configured.";
          description
            "Configure Entropy Label";
        }  // container entropy-label

        container signalling {
          description
            "Configure signalling parameters";
          leaf dscp {
            type uint32 {
              range "0..63";
            }
            description
              "Set DSCP for LDP control packets";
          }
        }  // container signalling

        container graceful-restart {
          presence
            "Indicates a graceful-restart node is configured.";
          description
            "Configure graceful restart feature";
        }  // container graceful-restart

        leaf graceful-restart-reconnect-timeout {
          type uint32 {
            range "60..1800";
          }
          description
            "Session Reconnect timeout";
        }

        leaf graceful-restart-forwarding-state-holdtime {
          type uint32 {
            range "60..1800";
          }
          description
            "Forwarding State holdtime for a restarting LSR";
        }

        container graceful-restart-helper-peer {
          description
            "Configure parameters related to GR peer(s) operating in helper mode";
          container maintain-on-local-reset {
            presence
              "Indicates a maintain-on-local-reset node is configured.";
            description
              "Maintain the state of a GR peer upon a local reset";
            leaf for {
              type string {
                length "1..32";
              }
              mandatory true;
              description
                "Access list of LDP Peers";
            }
          }  // container maintain-on-local-reset
        }  // container graceful-restart-helper-peer

        container igp {
          description
            "Configure igp parameters";
          container sync {
            description
              "Configure LDP-IGP synchronization parameters";
            container delay {
              description
                "Configure sync up delay after session up";
              leaf on-session-up {
                type uint32 {
                  range "5..300";
                }
                description
                  "Interface sync-up delay after session up";
              }

              leaf on-proc-restart {
                type uint32 {
                  range "60..600";
                }
                description
                  "Global sync up delay to be used after process restart";
              }
            }  // container delay
          }  // container sync
        }  // container igp

        leaf router-id {
          type inet:ipv4-address-no-zone;
          description "Configure router Id";
        }

        container capabilities {
          description
            "Configure LDP Capabilities";
          container cisco {
            description
              "Cisco capabilities options";
            container ios-xr {
              description
                "Cisco IOS-XR capabilities options";
              container disable {
                presence
                  "Indicates a disable node is configured.";
                description
                  "Disable Cisco IOS-XR capability";
              }  // container disable
            }  // container ios-xr
          }  // container cisco

          container sac {
            presence
              "Indicates a sac node is configured.";
            description
              "State Advertisement Control";
            container ipv4-disable {
              presence
                "Indicates a ipv4-disable node is configured.";
              description
                "Disable exchanging IPv4 prefix label bindings";
            }  // container ipv4-disable

            container ipv6-disable {
              presence
                "Indicates a ipv6-disable node is configured.";
              description
                "Disable exchanging IPv6 prefix label bindings";
            }  // container ipv6-disable

            container fec128-disable {
              presence
                "Indicates a fec128-disable node is configured.";
              description
                "Disable exchanging PW FEC128 label bindings";
            }  // container fec128-disable

            container fec129-disable {
              presence
                "Indicates a fec129-disable node is configured.";
              description
                "Disable exchanging PW FEC129 label bindings";
            }  // container fec129-disable
          }  // container sac
        }  // container capabilities

        container log {
          description
            "Configure logging of LDP events";
          container hello-adjacency {
            presence
              "Indicates a hello-adjacency node is configured.";
            description
              "Hello adjacency events";
          }  // container hello-adjacency

          container neighbor {
            presence
              "Indicates a neighbor node is configured.";
            description "Neighbor events";
          }  // container neighbor

          container nsr {
            presence
              "Indicates a nsr node is configured.";
            description
              "NSR synchronization events";
          }  // container nsr

          container graceful-restart {
            presence
              "Indicates a graceful-restart node is configured.";
            description
              "Graceful Restart events";
          }  // container graceful-restart

          container session-protection {
            presence
              "Indicates a session-protection node is configured.";
            description
              "Session Protection events";
          }  // container session-protection
        }  // container log

        container discovery {
          description
            "Configure discovery parameters";
          container hello {
            description "LDP Link Hellos";
            leaf holdtime {
              type uint32 {
                range "1..65535";
              }
              description "Hello holdtime";
            }

            leaf interval {
              type uint32 {
                range "1..65535";
              }
              description "Hello interval";
            }
          }  // container hello

          container targeted-hello {
            description
              "LDP Targeted Hellos";
            leaf holdtime {
              type uint32 {
                range "1..65535";
              }
              description
                "Targeted hello holdtime";
            }

            leaf interval {
              type uint32 {
                range "1..65535";
              }
              description
                "Targeted Hello interval";
            }
          }  // container targeted-hello

          container instance-tlv {
            description
              "Control support for Neighbor instance TLV in Hello messages";
            container disable {
              presence
                "Indicates a disable node is configured.";
              description
                "Disable transmit and receive processing for TLV";
            }  // container disable
          }  // container instance-tlv

          container ds-tlv {
            description
              "Control Dual Stack TLV sending";
            container disable {
              presence
                "Indicates a disable node is configured.";
              description
                "Disable transmit and receive processing for TLV";
            }  // container disable
          }  // container ds-tlv

          container quick-start {
            description
              "Control quick discovery and initial burst of hello";
            container disable {
              presence
                "Indicates a disable node is configured.";
              description
                "Disable quick discovery";
            }  // container disable
          }  // container quick-start
        }  // container discovery

        container neighbor {
          description
            "Configure neighbor parameters";
          container dual-stack {
            description
              "Configure dual stack ipv4/ipv6 neighbor parameters";
            container transport-connection {
              description
                "Configure TCP transport parameters for neighbors";
              container prefer {
                description
                  "Configure prefered address family for TCP transport connection with neighbors";
                container ipv4 {
                  presence
                    "Indicates a ipv4 node is configured.";
                  description "IPv4";
                }  // container ipv4
              }  // container prefer

              leaf max-wait {
                type uint32 {
                  range "0..60";
                }
                description
                  "Maximum wait for prefered transport connection establishment";
              }
            }  // container transport-connection

            container tlv-compliance {
              presence
                "Indicates a tlv-compliance node is configured.";
              description
                "Configure dual-stack tlv compliance checks";
            }  // container tlv-compliance
          }  // container dual-stack

          container password {
            description
              "Configure password for MD5 authentication for all neighbors";
            leaf encrypted {
              type xr:Proprietary-password;
              description
                "Specifies an ENCRYPTED password will follow";
            }
          }  // container password

          container neighbors {
            description "neighbor";
            list neighbor {
              key "neighbor-address label-space-id";
              description
                "configure this node";
              leaf neighbor-address {
                type inet:ipv4-address-no-zone;
                description
                  "configure this node";
              }

              leaf label-space-id {
                type uint32 {
                  range "0";
                }
                description
                  "Label Space Id of neighbor";
              }

              container password {
                description
                  "Configure password for MD5 authentication";
                leaf encrypted {
                  type xr:Proprietary-password;
                  must " not(../disable)";
                  description
                    "Specifies an ENCRYPTED password will follow";
                }

                container disable {
                  must " not(../encrypted)";
                  presence
                    "Indicates a disable node is configured.";
                  description
                    "Disables the global password from this neighbor";
                }  // container disable
              }  // container password
            }  // list neighbor
          }  // container neighbors
        }  // container neighbor

        container address-families {
          description
            "Configure Address Family and its parameters";
          list address-family {
            key "af-name";
            description
              "Configure Address Family and its parameters";
            leaf af-name {
              type enumeration {
                enum "ipv4" {
                  value 4;
                  description "IPv4";
                }
                enum "ipv6" {
                  value 6;
                  description "IPv6";
                }
              }
              description
                "Configure Address Family and its parameters";
            }

            container discovery {
              description
                "Configure discovery parameters";
              container transport-address {
                presence
                  "Indicates a transport-address node is configured.";
                description
                  "Specify transport address for TCP connection";
                leaf ip-address {
                  type inet:ip-address-no-zone;
                  mandatory true;
                  description
                    "IP address to be used as transport address";
                }
              }  // container transport-address

              container targeted-hello {
                description
                  "LDP Targeted Hellos";
                container accept {
                  presence
                    "Indicates a accept node is configured.";
                  description
                    "Accept and respond to targeted hellos";
                  leaf from {
                    type string {
                      length "1..1024";
                    }
                    description
                      "IP Access list to specify acceptable targeted hello sources";
                  }
                }  // container accept
              }  // container targeted-hello
            }  // container discovery

            container neighbor {
              description
                "Configure neighbor parameters";
              container addresses {
                description
                  "IP address of neighbor";
                list address {
                  key "neighbor-address";
                  description
                    "IP address of neighbor";
                  leaf neighbor-address {
                    type inet:ip-address-no-zone;
                    description
                      "IP address of neighbor";
                  }

                  container targeted {
                    presence
                      "Indicates a targeted node is configured.";
                    description
                      "Establish targeted session";
                  }  // container targeted
                }  // list address
              }  // container addresses

              container sr-policies {
                description
                  "Configure Segment Routing policy parameters";
                list sr-policy {
                  key "policy-name";
                  description
                    "Segment Routing policy name";
                  leaf policy-name {
                    type string {
                      length "1..59";
                    }
                    description
                      "Segment Routing policy name";
                  }

                  container targeted {
                    presence
                      "Indicates a targeted node is configured.";
                    description
                      "Establish targeted session";
                  }  // container targeted
                }  // list sr-policy
              }  // container sr-policies
            }  // container neighbor

            container traffic-eng {
              description
                "Configure LDP parameters for MPLS Traffic-Engineering (TE)";
              container auto-tunnel {
                description
                  "Configure LDP TE auto-tunnel related parameters";
                container mesh {
                  description
                    "Configure TE auto-tunnel mesh groups";
                  container groups {
                    description
                      "Configure an auto-tunnel mesh group of interfaces in LDP";
                    list group {
                      key "group-id";
                      description
                        "Configure an auto-tunnel mesh group of interfaces in LDP";
                      leaf group-id {
                        type uint32 {
                          range
                            "0..4294967295";
                        }
                        description
                          "Configure an auto-tunnel mesh group of interfaces in LDP";
                      }
                    }  // list group

                    container all {
                      presence
                        "Indicates a all node is configured.";
                      description
                        "Enable LDP on all TE meshgroup interfaces";
                    }  // container all
                  }  // container groups
                }  // container mesh
              }  // container auto-tunnel
            }  // container traffic-eng

            container redistribute {
              when "../af-name = 'ipv4'";
              description
                "Redistribute routes from routing protocols";
              container bgp {
                description
                  "Redistribute routes from BGP protocol";
                leaf as {
                  type xr:Bgp-as-number;
                  description
                    "bgp as-number";
                }

                leaf advertise-to {
                  type string {
                    length "1..1024";
                  }
                  description
                    "IP access list specifying LDP peers to advertise";
                }
              }  // container bgp
            }  // container redistribute

            container label {
              description
                "Configure label control and policies";
              container local {
                description
                  "Configure local label control and policies";
                container allocate {
                  description
                    "Configure label allocation control";
                  container for {
                    description
                      "Limit label allocation to a set of prefixes";
                    leaf access-list {
                      type string {
                        length "1..1024";
                      }
                      must
                        "not(../host-routes)";
                      description
                        "IP access-list";
                    }

                    container host-routes {
                      must
                        "not(../access-list)";
                      presence
                        "Indicates a host-routes node is configured.";
                      description
                        "Allocate label for host routes only";
                    }  // container host-routes
                  }  // container for
                }  // container allocate

                container default-route {
                  presence
                    "Indicates a default-route node is configured.";
                  description
                    "Enable MPLS forwarding for default route";
                }  // container default-route

                container implicit-null-override {
                  description
                    "Configure use of implicit-null local label for non-egress prefixes";
                  leaf for {
                    type string {
                      length "1..32";
                    }
                    description
                      "Limit implicit-null label use to a set of prefixes";
                  }
                }  // container implicit-null-override

                container advertise {
                  description
                    "Configure outbound label advertisement control";
                  container explicit-null {
                    must "not(for and to)";
                    presence
                      "Indicates a explicit-null node is configured.";
                    description
                      "Configure explicit-null advertisement";
                    container for {
                      presence
                        "Indicates a for node is configured.";
                      description
                        "IP Access-list specifying controls on destination prefixes";
                      leaf access-list {
                        type string {
                          length "1..1024";
                        }
                        mandatory true;
                        description
                          "IP Access-list specifying controls on destination prefixes";
                      }

                      container to {
                        presence
                          "Indicates a to node is configured.";
                        description
                          "IP Access-list specifying controls on LDP Peers";
                        leaf access-list {
                          type string {
                            length "1..1024";
                          }
                          mandatory true;
                          description
                            "IP Access-list specifying controls on LDP Peers";
                        }
                      }  // container to
                    }  // container for

                    container to {
                      presence
                        "Indicates a to node is configured.";
                      description
                        "IP Access-list specifying controls on LDP Peers";
                      leaf access-list {
                        type string {
                          length "1..1024";
                        }
                        mandatory true;
                        description
                          "IP Access-list specifying controls on LDP Peers";
                      }
                    }  // container to
                  }  // container explicit-null

                  container to {
                    description
                      "Peer centric outbound label filtering";
                    list neighbor {
                      key "neighbor-address label-space-id";
                      description "neighbor";
                      leaf neighbor-address {
                        type inet:ipv4-address-no-zone;
                        description
                          "neighbor address";
                      }

                      leaf label-space-id {
                        type uint32 {
                          range "0";
                        }
                        description
                          "Label Space Id of neighbor";
                      }

                      leaf for {
                        type string {
                          length "1..32";
                        }
                        mandatory true;
                        description
                          "IP access-list for prefixes to be sent";
                      }
                    }  // list neighbor
                  }  // container to

                  container interfaces {
                    description
                      "Advertise interface host address";
                    list interface {
                      key "interface-name";
                      description
                        "Advertise interface host address";
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Advertise interface host address";
                      }
                    }  // list interface
                  }  // container interfaces

                  container disable {
                    presence
                      "Indicates a disable node is configured.";
                    description
                      "Disable label advertisement to all peers for all prefixes";
                  }  // container disable

                  container for {
                    description
                      "Prefix centric outbound label filtering";
                    list access-lists {
                      key "access-list-name";
                      description
                        "Prefix centric outbound label filtering";
                      leaf access-list-name {
                        type xr:Cisco-ios-xr-string {
                          length "1..1024";
                        }
                        description
                          "Prefix centric outbound label filtering";
                      }

                      leaf to {
                        type string {
                          length "1..1024";
                        }
                        description
                          "IP access-list for LDP peers";
                      }
                    }  // list access-lists
                  }  // container for
                }  // container advertise
              }  // container local

              container remote {
                description
                  "Configure remote/peer label control and policies";
                container accept {
                  description
                    "Configure inbound label acceptance control";
                  container from {
                    description
                      "Neighbor from whom to accept label advertisement";
                    list neighbor {
                      key "neighbor-address label-space-id";
                      description
                        "Neighbor from whom to accept label advertisement";
                      leaf neighbor-address {
                        type inet:ipv4-address-no-zone;
                        description
                          "Neighbor from whom to accept label advertisement";
                      }

                      leaf label-space-id {
                        type uint32 {
                          range "0";
                        }
                        description
                          "Label Space Id of neighbor";
                      }

                      leaf for {
                        type string {
                          length "1..32";
                        }
                        description
                          "IP access-list for destination prefixes";
                      }
                    }  // list neighbor
                  }  // container from
                }  // container accept
              }  // container remote
            }  // container label
          }  // list address-family
        }  // container address-families

        container interfaces {
          description
            "Enable LDP on an interface and enter interface submode";
          list interface {
            key "interface-name";
            description
              "Enable LDP on an interface and enter interface submode";
            leaf interface-name {
              type xr:Interface-name;
              description
                "Enable LDP on an interface and enter interface submode";
            }

            container discovery {
              description
                "Configure discovery parameters";
              container hello {
                description
                  "LDP Link Hellos";
                leaf holdtime {
                  type uint32 {
                    range "1..65535";
                  }
                  description
                    "Hello holdtime";
                }

                leaf interval {
                  type uint32 {
                    range "1..65535";
                  }
                  description
                    "Hello interval";
                }

                leaf dual-stack-tlv {
                  type enumeration {
                    enum "ipv4" {
                      value 4;
                      description "IPv4";
                    }
                    enum "ipv6" {
                      value 6;
                      description "IPv6";
                    }
                  }
                  description
                    "Change AF preference in Dual Stack TLV";
                }
              }  // container hello

              container quick-start {
                description
                  "Control quick discovery and initial burst of hello";
                container disable {
                  presence
                    "Indicates a disable node is configured.";
                  description
                    "Disable quick discovery";
                }  // container disable
              }  // container quick-start
            }  // container discovery

            container igp {
              description
                "Configure igp parameters";
              container sync {
                description
                  "Configure LDP-IGP synchronization parameters";
                container delay {
                  description
                    "Configure sync up delay";
                  container on-session-up {
                    description
                      "Interface sync-up delay after session up";
                    leaf interface-sync-up-delay {
                      type uint32 {
                        range "5..300";
                      }
                      must "not(../disable)";
                      description
                        "Interface sync-up delay (seconds)";
                    }

                    container disable {
                      must
                        "not(../interface-sync-up-delay)";
                      presence
                        "Indicates a disable node is configured.";
                      description "Disable";
                    }  // container disable
                  }  // container on-session-up
                }  // container delay
              }  // container sync
            }  // container igp

            container address-families {
              description
                "Configure Address Family and its parameters";
              list address-family {
                key "af-name";
                description
                  "Configure Address Family and its parameters";
                leaf af-name {
                  type enumeration {
                    enum "ipv4" {
                      value 4;
                      description "IPv4";
                    }
                    enum "ipv6" {
                      value 6;
                      description "IPv6";
                    }
                  }
                  description
                    "Configure Address Family and its parameters";
                }

                container discovery {
                  description
                    "Configure discovery parameters";
                  container transport-address {
                    must
                      "(interface and not(ip-address)) or (ip-address and not(interface))";
                    presence
                      "Indicates a transport-address node is configured.";
                    description
                      "Specify interface LDP transport address";
                    container interface {
                      presence
                        "Indicates a interface node is configured.";
                      description
                        "Use this interface address as transport address";
                    }  // container interface

                    leaf ip-address {
                      type inet:ip-address-no-zone;
                      description
                        "IP address to be used as transport address";
                    }
                  }  // container transport-address
                }  // container discovery

                container igp {
                  description
                    "Configure igp parameters";
                  container auto-config {
                    description
                      "Auto-configuration";
                    container disable {
                      presence
                        "Indicates a disable node is configured.";
                      description "Disable";
                    }  // container disable
                  }  // container auto-config
                }  // container igp

                container mldp {
                  description
                    "Configure mLDP parameters";
                  container disable {
                    presence
                      "Indicates a disable node is configured.";
                    description
                      "Disable mLDP on LDP enabled interface";
                  }  // container disable
                }  // container mldp
              }  // list address-family
            }  // container address-families
          }  // list interface
        }  // container interfaces
      }  // container ldp
    }  // container mpls
  }  // module Cisco-IOS-XR-um-mpls-ldp-cfg