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

    yang-version 1;

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

    prefix mpls-ldp-cfg;

    import ietf-inet-types {
      prefix inet;
    }
    import Cisco-IOS-XR-types {
      prefix xr;
    }
    import cisco-semver {
      prefix semver;
    }
    import Cisco-IOS-XR-snmp-agent-cfg {
      prefix a1;
    }

    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 model is deprecated and is replaced by
     Cisco-IOS-XR-um-mpls-ldp-cfg.yang which will provide the
     compatible functionalities.
     
     This module contains definitions
     for the following management objects:
       mpls-ldp: MPLS LDP configuration
     
     This YANG module augments the
       Cisco-IOS-XR-snmp-agent-cfg
     module with configuration data.
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-08-31" {
      description "New ELC config added.";
    }

    revision "2019-06-05" {
      description
        "Added SAC capabilities to schema";
    }

    revision "2019-05-12" {
      description
        "Deprecated the native model, replaced by UM model.";
    }

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

    revision "2018-06-15" {
      description
        "Allow min..max in range when min == max.";
    }

    revision "2017-09-30" {
      description
        "Ensure propagation of MDA mandatory state to YANG model.";
    }

    revision "2017-06-26" {
      description
        "Change identifiers to be more readable.";
    }

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

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

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

    typedef Mpls-ldp-nbr-password {
      type enumeration {
        enum "disable" {
          value 1;
          description
            "Disable the global default password for this
           neighbor";
        }
        enum "specified" {
          value 2;
          description
            "Specify a password for this neighbor";
        }
      }
      description "Mpls ldp nbr password";
    }

    typedef Mpls-ldp-label-allocation {
      type enumeration {
        enum "acl" {
          value 1;
          description
            "Allocate label for prefixes permitted by ACL";
        }
        enum "host" {
          value 2;
          description
            "Allocate label for host routes only";
        }
      }
      description
        "Mpls ldp label allocation";
    }

    typedef Mpls-ldp-downstream-on-demand {
      type enumeration {
        enum "peer-acl" {
          value 1;
          description
            "Downstream on Demand peers permitted by ACL";
        }
      }
      description
        "Mpls ldp downstream on demand";
    }

    typedef Mldp-policy-mode {
      type enumeration {
        enum "inbound" {
          value 1;
          description "Inbound route policy";
        }
        enum "outbound" {
          value 2;
          description
            "Outbound route policy";
        }
      }
      description "Mldp policy mode";
    }

    typedef Mpls-ldp-targeted-accept {
      type enumeration {
        enum "all" {
          value 1;
          description
            "Accept targeted hello from all";
        }
        enum "from" {
          value 2;
          description
            "Accept targeted hello from peer ACL";
        }
      }
      description "Mpls ldp targeted accept";
    }

    typedef Mpls-ldp-interval-time {
      type uint32 {
        range "1..65535";
      }
      description "Mpls ldp interval time";
    }

    typedef Mpls-ldp-mesh-group-id {
      type uint32 {
        range "0..4294967295";
      }
      description "Mpls ldp mesh group id";
    }

    typedef Mpls-ldp-exp-null {
      type enumeration {
        enum "all" {
          value 1;
          description
            "Advertise explicit-null for all connected
           prefixes to all peers";
        }
        enum "for" {
          value 2;
          description
            "Advertise explicit-null for prefix(es)
           permitted by prefix ACL";
        }
        enum "to" {
          value 3;
          description
            "Advertise explicit-null for all connected
           prefixes to peer(s) permitted by peer ACL";
        }
        enum "for-to" {
          value 4;
          description
            "Advertise explicit-null for prefix(es)
           permitted by prefix ACL to peer(s) permitted by
           peer ACL";
        }
      }
      description "Mpls ldp exp null";
    }

    typedef Mpls-ldp-hold-time {
      type uint32 {
        range "1..65535";
      }
      description "Mpls ldp hold time";
    }

    typedef Mpls-ldp-dscp {
      type uint32 {
        range "0..63";
      }
      description "Mpls ldp dscp";
    }

    typedef Mpls-ldpaf-name {
      type enumeration {
        enum "ipv4" {
          value 4;
          description "IPv4";
        }
        enum "ipv6" {
          value 6;
          description "IPv6";
        }
      }
      description "Mpls ldpaf name";
    }

    typedef Mpls-ldp-transport-address {
      type enumeration {
        enum "interface" {
          value 1;
          description
            "Use interface IP address";
        }
        enum "address" {
          value 2;
          description "Use given IP address";
        }
      }
      description
        "Mpls ldp transport address";
    }

    typedef Mpls-ldp-session-protection {
      type enumeration {
        enum "all" {
          value 1;
          description
            "Protect all peer sessions";
        }
        enum "for" {
          value 2;
          description
            "Protect peer session(s) permitted by peer ACL";
        }
        enum "all-with-duration" {
          value 3;
          description
            "Protect all peer sessions and holdup protection
           for given duration";
        }
        enum "for-with-duration" {
          value 4;
          description
            "Protect peer session(s) permitted by peer ACL
           and holdup protection for given duration";
        }
        enum "all-with-forever" {
          value 5;
          description
            "Protect all peer sessions and holdup protection
           forever";
        }
        enum "for-with-forever" {
          value 6;
          description
            "Protect peer session(s) permitted by peer ACL
           and holdup protection forever";
        }
      }
      description
        "Mpls ldp session protection";
    }

    typedef Mpls-ldp-label-advertise {
      type enumeration {
        enum "for" {
          value 1;
          description
            "Advertise label for prefix(es) permitted by
           prefix ACL";
        }
        enum "for-to" {
          value 2;
          description
            "Advertise label for prefix(es) permitted by
           prefix ACL to peer(s) permitted by peer ACL";
        }
      }
      description "Mpls ldp label advertise";
    }

    typedef Mpls-ldp-advertise-bgp-acl {
      type enumeration {
        enum "peer-acl" {
          value 1;
          description
            "BGP prefixes advertised to peers permitted by
           ACL";
        }
      }
      description
        "Mpls ldp advertise bgp acl";
    }

    grouping ENABLE {
      description "Common node of mldp, vrf";
      leaf enable {
        type empty;
        description
          "Enable Multicast Label Distribution Protocol
         (mLDP)";
      }
    }  // grouping ENABLE

    grouping AF-TABLE {
      description
        "Common node of default-vrf, vrf";
      container afs {
        description
          "Address Family specific operational data";
        list af {
          key "af-name";
          description
            "Operational data for given Address Family";
          container recursive-forwarding {
            description
              "Enable recursive forwarding";
            leaf enable {
              type empty;
              description
                "Enable recursive forwarding";
            }

            leaf policy {
              type string {
                length "1..64";
              }
              description
                "Recursive forwarding policy name";
            }
          }  // container recursive-forwarding

          container mldp-recursive-fec {
            description
              "MPLS mLDP Recursive FEC";
            leaf enable {
              type empty;
              description
                "Enable MPLS mLDP Recursive FEC";
            }

            leaf policy {
              type string {
                length "1..64";
              }
              description
                "Route policy name";
            }
          }  // container mldp-recursive-fec

          container neighbor-policies {
            description
              "MLDP neighbor policies";
            list neighbor-policy {
              key "root-address policy-mode";
              description "Route Policy";
              leaf root-address {
                type inet:ipv4-address-no-zone;
                description
                  "Neighbor Address";
              }

              leaf policy-mode {
                type Mldp-policy-mode;
                description
                  "Inbound/Outbound Policy";
              }

              leaf route-policy {
                type string {
                  length "1..64";
                }
                mandatory true;
                description
                  "Route policy name";
              }
            }  // list neighbor-policy
          }  // container neighbor-policies

          container mo-frr {
            description "MPLS mLDP MoFRR";
            leaf enable {
              type empty;
              description
                "Enable MPLS mLDP MoFRR";
            }

            leaf policy {
              type string {
                length "1..64";
              }
              description
                "Route policy name";
            }
          }  // container mo-frr

          container make-before-break {
            description
              "MPLS mLDP Make-Before-Break configuration";
            container signaling {
              description
                "Enable MPLS mLDP MBB signaling";
              leaf forward-delay {
                type uint32 {
                  range "0..600";
                }
                units "second";
                description
                  "Forwarding Delay in Seconds";
              }

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

            leaf policy {
              type string {
                length "1..64";
              }
              description
                "Route policy name";
            }
          }  // container make-before-break

          container csc {
            description "MPLS mLDP CSC";
            leaf enable {
              type empty;
              description
                "Enable MPLS mLDP CSC";
            }
          }  // container csc

          leaf enable {
            type empty;
            description
              "Enable Multicast Label Distribution Protocol
             (mLDP) under AF.";
          }

          leaf mldp-rib-unicast-always {
            type empty;
            description
              "Enable MPLS MLDP RIB unicast-always
             configuration";
          }

          leaf af-name {
            type Mpls-ldpaf-name;
            description
              "Address Family name";
          }
        }  // list af
      }  // container afs
    }  // grouping AF-TABLE

    augment /a1:snmp/a1:notification {
      description
        "This augment extends the configuration data of
       'Cisco-IOS-XR-snmp-agent-cfg'";
      container mpls-ldp {
        status deprecated;
        description
          "This model is deprecated and is replaced by
         Cisco-IOS-XR-um-mpls-ldp-cfg.yang which will
         provide the compatible functionalities.
         MPLS-LDP-STD-MIB notification configuration";
        leaf session-up {
          type empty;
          description
            "Enable mplsLdpSessionUp notification";
        }

        leaf init-session-threshold-exceeded {
          type empty;
          description
            "Enable mplsLdpInitSessionThresholdExceeded
           notification";
        }

        leaf session-down {
          type empty;
          description
            "Enable mplsLdpSessionDown notification";
        }
      }  // container mpls-ldp
    }

    container mpls-ldp {
      presence
        "Indicates a mpls-ldp node is configured.";
      status deprecated;
      description
        "This model is deprecated and is replaced by
       Cisco-IOS-XR-um-mpls-ldp-cfg.yang which will
       provide the compatible functionalities.  MPLS LDP
       configuration";
      container default-vrf {
        description
          "Global VRF attribute configuration for MPLS LDP";
        container afs {
          description
            "Address Family specific configuration for MPLS
           LDP";
          list af {
            key "af-name";
            description
              "Configure data for given Address Family";
            container label {
              description
                "Configure Label policies and control";
              container remote {
                description
                  "Configure remote/peer label policies and
                 control";
                container accept {
                  description
                    "Configure inbound label acceptance";
                  container peer-accept-policies {
                    description
                      "Configuration related to neighbors for
                     inbound label acceptance";
                    list peer-accept-policy {
                      key "lsr-id label-space-id";
                      description
                        "Control acceptance of labels from a
                       neighbor for prefix(es) using ACL";
                      leaf lsr-id {
                        type inet:ipv4-address-no-zone;
                        description
                          "LSR ID of neighbor";
                      }

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

                      leaf prefix-acl-name {
                        type string;
                        mandatory true;
                        description
                          "Name of prefix ACL";
                      }
                    }  // list peer-accept-policy
                  }  // container peer-accept-policies
                }  // container accept
              }  // container remote

              container local {
                description
                  "Configure local label policies and control";
                container advertise {
                  description
                    "Configure outbound label advertisement";
                  container peer-advertise-policies {
                    description
                      "Configure peer centric outbound label
                     advertisement using ACL";
                    list peer-advertise-policy {
                      key "lsr-id label-space-id";
                      description
                        "Control advertisement of prefix(es) using
                       ACL";
                      leaf lsr-id {
                        type inet:ipv4-address-no-zone;
                        description
                          "LSR ID of neighbor";
                      }

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

                      leaf prefix-acl-name {
                        type string;
                        mandatory true;
                        description
                          "Name of prefix ACL";
                      }
                    }  // list peer-advertise-policy
                  }  // container peer-advertise-policies

                  container prefix-advertise-policies {
                    description
                      "Configure prefix centric outbound label
                     advertisement using ACL";
                    list prefix-advertise-policy {
                      key "prefix-acl-name";
                      description
                        "Control advertisement of prefix(es) using
                       ACL";
                      leaf prefix-acl-name {
                        type xr:Cisco-ios-xr-string;
                        description
                          "Name of prefix ACL";
                      }

                      leaf advertise-type {
                        type Mpls-ldp-label-advertise;
                        description
                          "Label advertise type";
                      }

                      leaf peer-acl-name {
                        when
                          "../advertise-type = 'for-to'" {
                          description
                            "../AdvertiseType = ForTo";
                        }
                        type string;
                        description
                          "Name of peer ACL";
                      }
                    }  // list prefix-advertise-policy
                  }  // container prefix-advertise-policies

                  container explicit-null {
                    description
                      "Configure advertisment of explicit-null
                     for connected prefixes.";
                    leaf explicit-null-type {
                      type Mpls-ldp-exp-null;
                      description
                        "Explicit Null command variant";
                    }

                    leaf prefix-acl-name {
                      when
                        "../explicit-null-type = 'for' or ../explicit-null-type = 'for-to'" {
                        description
                          "../ExplicitNullType = For or .
                         ./ExplicitNullType = ForTo";
                      }
                      type string;
                      description
                        "Name of prefix ACL";
                    }

                    leaf peer-acl-name {
                      when
                        "../explicit-null-type = 'to' or ../explicit-null-type = 'for-to'" {
                        description
                          "../ExplicitNullType = To or .
                         ./ExplicitNullType = ForTo";
                      }
                      type string;
                      description
                        "Name of peer ACL";
                    }
                  }  // container explicit-null

                  container interfaces {
                    description
                      "Configure outbound label advertisement for
                     an interface";
                    list interface {
                      key "interface-name";
                      description
                        "Control advertisement of interface's host
                       IP address";
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Name of interface";
                      }
                    }  // list interface
                  }  // container interfaces

                  leaf disable {
                    type empty;
                    description
                      "Disable label advertisement";
                  }
                }  // container advertise

                container allocate {
                  description
                    "Control local label allocation for
                   prefix(es)";
                  leaf allocation-type {
                    type Mpls-ldp-label-allocation;
                    description
                      "Label allocation type";
                  }

                  leaf prefix-acl-name {
                    when
                      "../allocation-type = 'acl'" {
                      description
                        "../AllocationType = ACL";
                    }
                    type string;
                    description
                      "Name of prefix ACL";
                  }
                }  // container allocate

                leaf implicit-null-override {
                  type string;
                  description
                    "Control use of implicit-null label for set
                   of prefix(es)";
                }

                leaf default-route {
                  type empty;
                  description
                    "Enable MPLS forwarding for default route";
                }
              }  // container local
            }  // container label

            container discovery {
              description
                "Configure Discovery parameters";
              container targeted-hello-accept {
                description
                  "Configure acceptance from and responding to
                 targeted hellos.";
                leaf accept-type {
                  type Mpls-ldp-targeted-accept;
                  description
                    "Type of acceptance";
                }

                leaf peer-acl-name {
                  when
                    "../accept-type = 'from'" {
                    description
                      "../AcceptType = From";
                  }
                  type string;
                  description
                    "Name of peer ACL";
                }
              }  // container targeted-hello-accept

              leaf transport-address {
                type inet:ip-address-no-zone;
                description
                  "Global discovery transport address for
                 address family";
              }
            }  // container discovery

            container traffic-engineering {
              description
                "MPLS Traffic Engingeering parameters for LDP";
              container auto-tunnel-mesh {
                description
                  "MPLS Traffic Engineering auto-tunnel mesh
                 parameters for LDP";
                container group-ids {
                  description
                    "Enable interfaces in specific MPLS TE
                   auto-tunnel mesh-groups";
                  list group-id {
                    key "mesh-group-id";
                    description
                      "Auto-mesh group identifier to enable";
                    leaf mesh-group-id {
                      type Mpls-ldp-mesh-group-id;
                      description
                        "Mesh group ID";
                    }
                  }  // list group-id
                }  // container group-ids

                leaf group-all {
                  type empty;
                  description
                    "Enable all MPLS TE auto-tunnel mesh-group
                   interfaces";
                }
              }  // container auto-tunnel-mesh
            }  // container traffic-engineering

            container neighbor {
              description
                "Configuration related to Neighbors";
              container addresses {
                description
                  "Configuration related to neighbors using
                 neighbor address";
                list address {
                  key "ip-address";
                  description
                    "IP address based configuration related to a
                   neighbor";
                  leaf targeted {
                    type empty;
                    description
                      "Establish targeted session with given
                     address";
                  }

                  leaf ip-address {
                    type inet:ip-address-no-zone;
                    description
                      "The IP address";
                  }
                }  // list address
              }  // container addresses

              container segment-routing-policies {
                description
                  "Configuration related to SR policies";
                list segment-routing-policy {
                  key "name";
                  description
                    "Name based configuration related to a SR
                   policy";
                  leaf targeted {
                    type empty;
                    description
                      "Establish targeted session with given
                     address";
                  }

                  leaf name {
                    type xr:Cisco-ios-xr-string;
                    description
                      "SR Policy Name";
                  }
                }  // list segment-routing-policy
              }  // container segment-routing-policies
            }  // container neighbor

            container redistribution-protocol {
              description
                "MPLS LDP configuration for protocol
               redistribution";
              container bgp {
                description
                  "MPLS LDP configuration for protocol
                 redistribution";
                container as {
                  description
                    "MPLS LDP configuration for protocol
                   redistribution";
                  leaf as-xx {
                    type uint32 {
                      range "0..65535";
                    }
                    description
                      "First half of BGP AS number in XX.YY
                     format.  Mandatory Must be a non-zero
                     value if second half is zero.";
                  }

                  leaf as-yy {
                    type uint32 {
                      range "0..4294967295";
                    }
                    description
                      "Second half of BGP AS number in XX.YY
                     format. Mandatory Must be a non-zero value
                     if first half is zero.";
                  }
                }  // container as

                container advertise-to {
                  description
                    "ACL containing list of neighbors for BGP
                   route redistribution";
                  leaf type {
                    type Mpls-ldp-advertise-bgp-acl;
                    description
                      "advertise to peer acl type";
                  }

                  leaf peer-acl-name {
                    when
                      "../type = 'peer-acl'" {
                      description
                        "../Type = PeerACL";
                    }
                    type string;
                    description
                      "Name of peer ACL";
                  }
                }  // container advertise-to
              }  // container bgp
            }  // container redistribution-protocol

            leaf enable {
              type empty;
              description
                "Enable Address Family";
            }

            leaf af-name {
              type Mpls-ldpaf-name;
              description
                "Address Family type";
            }
          }  // list af
        }  // container afs

        container global {
          description
            "Default VRF Global configuration for MPLS LDP";
          container session {
            description
              "LDP Session parameters";
            container protection {
              description
                "Configure Session Protection parameters";
              leaf protection-type {
                type Mpls-ldp-session-protection;
                description
                  "Session protection type";
              }

              leaf peer-acl-name {
                when
                  "../protection-type = 'for' or ../protection-type = 'for-with-duration' or ../protection-type = 'for-with-forever'" {
                  description
                    "../ProtectionType = For or .
                   ./ProtectionType = ForWithDuration or .
                   ./ProtectionType = ForWithForever";
                }
                type string;
                description
                  "Name of peer ACL";
              }

              leaf duration {
                when
                  "../protection-type = 'all-with-duration' or ../protection-type = 'for-with-duration'" {
                  description
                    "../ProtectionType = AllWithDuration or .
                   ./ProtectionType = ForWithDuration";
                }
                type uint32 {
                  range "30..2147483";
                }
                description
                  "Holdup duration";
              }
            }  // container protection

            container downstream-on-demand {
              description
                "ACL with the list of neighbors configured for
               Downstream on Demand";
              leaf type {
                type Mpls-ldp-downstream-on-demand;
                description
                  "Downstream on demand type";
              }

              leaf peer-acl-name {
                when "../type = 'peer-acl'" {
                  description
                    "../Type = PeerACL";
                }
                type string;
                description
                  "Name of peer ACL";
              }
            }  // container downstream-on-demand
          }  // container session

          container neighbor {
            description
              "Configuration related to Neighbors";
            container ldp-ids {
              description
                "Configuration related to Neighbors using LDP
               Id";
              list ldp-id {
                key "lsr-id label-space-id";
                description
                  "LDP ID based configuration related to a
                 neigbor";
                container password {
                  description
                    "Password for MD5 authentication for this
                   neighbor";
                  leaf command-type {
                    type Mpls-ldp-nbr-password;
                    description
                      "Command type for password configuration";
                  }

                  leaf password {
                    when
                      "../command-type = 'specified'" {
                      description
                        "../CommandType = Specified";
                    }
                    type xr:Proprietary-password;
                    description
                      "The neighbor password";
                  }
                }  // container password

                leaf lsr-id {
                  type inet:ipv4-address-no-zone;
                  description
                    "LSR ID of neighbor";
                }

                leaf label-space-id {
                  type uint32 {
                    range "0";
                  }
                  description
                    "Label space ID of neighbor";
                }
              }  // list ldp-id
            }  // container ldp-ids

            container dual-stack {
              description
                "Configuration related to neighbor transport";
              container transport-connection {
                description
                  "Configuration related to neighbor transport";
                container prefer {
                  description
                    "Configuration related to neighbor
                   dual-stack xport-connection preference";
                  leaf ipv4 {
                    type empty;
                    description
                      "Configuration related to neighbor
                     dual-stack xport-connection preference
                     ipv4";
                  }
                }  // container prefer

                leaf max-wait {
                  type uint32 {
                    range "0..60";
                  }
                  units "second";
                  description
                    "Configuration related to neighbor
                   dual-stack xport-connection max-wait";
                }
              }  // container transport-connection

              leaf tlv-compliance {
                type empty;
                description
                  "Configuration to enable neighbor dual-stack
                 tlv-compliance";
              }
            }  // container dual-stack

            leaf password {
              type xr:Proprietary-password;
              description
                "Default password for all neigbors";
            }
          }  // container neighbor

          container graceful-restart {
            description
              "Configuration for per-VRF LDP Graceful Restart
             parameters";
            container helper-peer {
              description
                "Configure parameters related to GR peer(s)
               opearating in helper mode";
              leaf maintain-on-local-reset {
                type string;
                description
                  "Maintain the state of a GR peer upon a local
                 reset";
              }
            }  // container helper-peer
          }  // container graceful-restart

          leaf router-id {
            type inet:ipv4-address-no-zone;
            description
              "Configuration for LDP Router ID (LDP ID)";
          }
        }  // container global

        container interfaces {
          description
            "MPLS LDP configuration pertaining to interfaces";
          list interface {
            key "interface-name";
            description
              "MPLS LDP configuration for a particular
             interface";
            container afs {
              description
                "Address Family specific configuration for
               MPLS LDP intf";
              list af {
                key "af-name";
                description
                  "Configure data for given Address Family";
                container discovery {
                  description
                    "Configure interface discovery parameters";
                  container transport-address {
                    description
                      "MPLS LDP configuration for interface
                     discovery transportaddress.";
                    leaf address-type {
                      type Mpls-ldp-transport-address;
                      description
                        "Transport address option";
                    }

                    leaf address {
                      when
                        "../address-type = 'address'" {
                        description
                          "../AddressType = Address";
                      }
                      type inet:ip-address-no-zone;
                      description
                        "IP address";
                    }
                  }  // container transport-address
                }  // container discovery

                container igp {
                  description
                    "LDP interface IGP configuration";
                  leaf disable-auto-config {
                    type empty;
                    description
                      "Disable IGP Auto-config on this interface";
                  }
                }  // container igp

                container mldp {
                  description
                    "Interface configuration parameters for mLDP";
                  leaf disable {
                    type empty;
                    description
                      "Disable mLDP on LDP enabled interface";
                  }
                }  // container mldp

                leaf enable {
                  type empty;
                  description
                    "Enable Address Family";
                }

                leaf af-name {
                  type Mpls-ldpaf-name;
                  description
                    "Address Family name";
                }
              }  // list af
            }  // container afs

            container global {
              description
                "Per VRF interface Global configuration for
               MPLS LDP";
              container discovery {
                description
                  "Configure interface discovery parameters";
                container link-hello {
                  description
                    "LDP Link Hellos";
                  leaf interval {
                    type Mpls-ldp-interval-time;
                    units "second";
                    default "5";
                    description
                      "Link Hello interval";
                  }

                  leaf dual-stack {
                    type Mpls-ldpaf-name;
                    default "ipv4";
                    description
                      "Dual Stack Address Family Preference";
                  }

                  leaf hold-time {
                    type Mpls-ldp-hold-time;
                    units "second";
                    default "15";
                    description
                      "Time (seconds) - 65535 implies infinite";
                  }
                }  // container link-hello

                leaf disable-quick-start {
                  type empty;
                  description
                    "Disable discovery's quick start mode";
                }
              }  // container discovery

              container igp {
                description
                  "LDP IGP configuration";
                container sync {
                  description
                    "LDP IGP synchronization";
                  container delay {
                    description
                      "LDP IGP synchronization delay time";
                    container on-session-up {
                      description
                        "Interface sync up delay after session up";
                      leaf disable {
                        type empty;
                        description
                          "Disable delay after session up";
                      }

                      leaf timeout {
                        type uint32 {
                          range "5..300";
                        }
                        units "second";
                        description
                          "Time (seconds)";
                      }
                    }  // container on-session-up
                  }  // container delay
                }  // container sync
              }  // container igp
            }  // container global

            leaf enable {
              type empty;
              description
                "Enable Label Distribution Protocol (LDP) on
               thisinterface";
            }

            leaf interface-name {
              type xr:Interface-name;
              description
                "Name of interface";
            }
          }  // list interface
        }  // container interfaces
      }  // container default-vrf

      container vrfs {
        description
          "VRF Table attribute configuration for MPLS LDP";
        list vrf {
          key "vrf-name";
          description
            "VRF attribute configuration for MPLS LDP";
          container global {
            description
              "Per VRF Global configuration for MPLS LDP";
            container session {
              description
                "LDP Session parameters";
              container downstream-on-demand {
                description
                  "ACL with the list of neighbors configured
                 for Downstream on Demand";
                leaf type {
                  type Mpls-ldp-downstream-on-demand;
                  description
                    "Downstream on demand type";
                }

                leaf peer-acl-name {
                  when
                    "../type = 'peer-acl'" {
                    description
                      "../Type = PeerACL";
                  }
                  type string;
                  description
                    "Name of peer ACL";
                }
              }  // container downstream-on-demand
            }  // container session

            container neighbor {
              description
                "Configuration related to Neighbors";
              container dual-stack {
                description
                  "Configuration related to neighbor transport";
                container transport-connection {
                  description
                    "Configuration related to neighbor transport";
                  container prefer {
                    description
                      "Configuration related to neighbor
                     dual-stack xport-connection preference";
                    leaf ipv4 {
                      type empty;
                      description
                        "Configuration related to neighbor
                       dual-stack xport-connection preference
                       ipv4";
                    }
                  }  // container prefer

                  leaf max-wait {
                    type uint32 {
                      range "0..60";
                    }
                    units "second";
                    description
                      "Configuration related to neighbor
                     dual-stack xport-connection max-wait";
                  }
                }  // container transport-connection
              }  // container dual-stack

              container ldp-ids {
                description
                  "Configuration related to Neighbors using LDP
                 Id";
                list ldp-id {
                  key "lsr-id label-space-id";
                  description
                    "LDP ID based configuration related to a
                   neigbor";
                  container password {
                    description
                      "Password for MD5 authentication for this
                     neighbor";
                    leaf command-type {
                      type Mpls-ldp-nbr-password;
                      description
                        "Command type for password configuration";
                    }

                    leaf password {
                      when
                        "../command-type = 'specified'" {
                        description
                          "../CommandType = Specified";
                      }
                      type xr:Proprietary-password;
                      description
                        "The neighbor password";
                    }
                  }  // container password

                  leaf lsr-id {
                    type inet:ipv4-address-no-zone;
                    description
                      "LSR ID of neighbor";
                  }

                  leaf label-space-id {
                    type uint32 {
                      range "0";
                    }
                    description
                      "Label space ID of neighbor";
                  }
                }  // list ldp-id
              }  // container ldp-ids

              leaf password {
                type xr:Proprietary-password;
                description
                  "Default password for all neigbors";
              }
            }  // container neighbor

            container graceful-restart {
              description
                "Configuration for per-VRF LDP Graceful
               Restart parameters";
              container helper-peer {
                description
                  "Configure parameters related to GR peer(s)
                 opearating in helper mode";
                leaf maintain-on-local-reset {
                  type string;
                  description
                    "Maintain the state of a GR peer upon a
                   local reset";
                }
              }  // container helper-peer
            }  // container graceful-restart

            leaf router-id {
              type inet:ipv4-address-no-zone;
              description
                "Configuration for LDP Router ID (LDP ID)";
            }
          }  // container global

          container afs {
            description
              "Address Family specific configuration for MPLS
             LDP vrf";
            list af {
              key "af-name";
              description
                "Configure data for given Address Family";
              container discovery {
                description
                  "Configure Discovery parameters";
                leaf transport-address {
                  type inet:ip-address-no-zone;
                  description
                    "Global discovery transport address for
                   address family";
                }
              }  // container discovery

              container label {
                description
                  "Configure Label policies and control";
                container remote {
                  description
                    "Configure remote/peer label policies and
                   control";
                  container accept {
                    description
                      "Configure inbound label acceptance";
                    container peer-accept-policies {
                      description
                        "Configuration related to Neighbors for
                       inbound label acceptance";
                      list peer-accept-policy {
                        must
                          "peer-accept-policy-data or lsr-id" {
                          description
                            "peer-accept-policy-data or lsr-id must
                           be present.";
                        }
                        key "label-space-id";
                        description
                          "Control acceptasnce of labels from a
                         neighbor for prefix(es) using ACL";
                        grouping PEER-ACCEPT-POLICY-CONTENT {
                          description
                            "Content grouping.";
                          leaf prefix-acl-name {
                            type string;
                            mandatory true;
                            description
                              "Name of prefix ACL";
                          }
                        }  // grouping PEER-ACCEPT-POLICY-CONTENT
                        container peer-accept-policy-data {
                          description
                            "Data container.";
                          uses PEER-ACCEPT-POLICY-CONTENT;
                        }  // container peer-accept-policy-data

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

                        list lsr-id {
                          key "lsr-id";
                          description
                            "keys: lsr-id";
                          leaf lsr-id {
                            type inet:ipv4-address-no-zone;
                            description
                              "LSR ID of neighbor";
                          }

                          uses PEER-ACCEPT-POLICY-CONTENT;
                        }  // list lsr-id
                      }  // list peer-accept-policy
                    }  // container peer-accept-policies
                  }  // container accept
                }  // container remote

                container local {
                  description
                    "Configure local label policies and control";
                  container advertise {
                    description
                      "Configure outbound label advertisement";
                    container peer-advertise-policies {
                      description
                        "Configure peer centric outbound label
                       advertisement using ACL";
                      list peer-advertise-policy {
                        must
                          "peer-advertise-policy-data or lsr-id" {
                          description
                            "peer-advertise-policy-data or lsr-id
                           must be present.";
                        }
                        key "label-space-id";
                        description
                          "Control advertisement of prefix(es)
                         using ACL";
                        grouping PEER-ADVERTISE-POLICY-CONTENT {
                          description
                            "Content grouping.";
                          leaf prefix-acl-name {
                            type string;
                            mandatory true;
                            description
                              "Name of prefix ACL";
                          }
                        }  // grouping PEER-ADVERTISE-POLICY-CONTENT
                        container peer-advertise-policy-data {
                          description
                            "Data container.";
                          uses PEER-ADVERTISE-POLICY-CONTENT;
                        }  // container peer-advertise-policy-data

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

                        list lsr-id {
                          key "lsr-id";
                          description
                            "keys: lsr-id";
                          leaf lsr-id {
                            type inet:ipv4-address-no-zone;
                            description
                              "LSR ID of neighbor";
                          }

                          uses PEER-ADVERTISE-POLICY-CONTENT;
                        }  // list lsr-id
                      }  // list peer-advertise-policy
                    }  // container peer-advertise-policies

                    container interfaces {
                      description
                        "Configure outbound label advertisement
                       for an interface";
                      list interface {
                        key "interface-name";
                        description
                          "Control advertisement of interface's
                         host IP address";
                        leaf interface-name {
                          type xr:Interface-name;
                          description
                            "Name of interface";
                        }
                      }  // list interface
                    }  // container interfaces

                    container explicit-null {
                      description
                        "Configure advertisment of explicit-null
                       for connected prefixes.";
                      leaf explicit-null-type {
                        type Mpls-ldp-exp-null;
                        description
                          "Explicit Null command variant";
                      }

                      leaf prefix-acl-name {
                        when
                          "../explicit-null-type = 'for' or ../explicit-null-type = 'for-to'" {
                          description
                            "../ExplicitNullType = For or .
                           ./ExplicitNullType = ForTo";
                        }
                        type string;
                        description
                          "Name of prefix ACL";
                      }

                      leaf peer-acl-name {
                        when
                          "../explicit-null-type = 'to' or ../explicit-null-type = 'for-to'" {
                          description
                            "../ExplicitNullType = To or .
                           ./ExplicitNullType = ForTo";
                        }
                        type string;
                        description
                          "Name of peer ACL";
                      }
                    }  // container explicit-null

                    leaf disable {
                      type empty;
                      description
                        "Disable label advertisement";
                    }
                  }  // container advertise

                  container allocate {
                    description
                      "Control local label allocation for
                     prefix(es)";
                    leaf allocation-type {
                      type Mpls-ldp-label-allocation;
                      description
                        "Label allocation type";
                    }

                    leaf prefix-acl-name {
                      when
                        "../allocation-type = 'acl'" {
                        description
                          "../AllocationType = ACL";
                      }
                      type string;
                      description
                        "Name of prefix ACL";
                    }
                  }  // container allocate

                  leaf implicit-null-override {
                    type string;
                    description
                      "Control use of implicit-null label for set
                     of prefix(es)";
                  }

                  leaf default-route {
                    type empty;
                    description
                      "Enable MPLS forwarding for default route";
                  }
                }  // container local
              }  // container label

              leaf enable {
                type empty;
                description
                  "Enable Address Family";
              }

              leaf af-name {
                type Mpls-ldpaf-name;
                description
                  "Address Family name";
              }
            }  // list af
          }  // container afs

          container interfaces {
            description
              "MPLS LDP configuration pertaining to
             interfaces";
            list interface {
              key "interface-name";
              description
                "MPLS LDP configuration for a particular
               interface";
              container afs {
                description
                  "Address Family specific configuration for
                 MPLS LDP vrf intf";
                list af {
                  key "af-name";
                  description
                    "Configure data for given Address Family";
                  container discovery {
                    description
                      "Configure interface discovery parameters";
                    container transport-address {
                      description
                        "MPLS LDP configuration for interface
                       discovery transportaddress.";
                      leaf address-type {
                        type Mpls-ldp-transport-address;
                        description
                          "Transport address option";
                      }

                      leaf address {
                        when
                          "../address-type = 'address'" {
                          description
                            "../AddressType = Address";
                        }
                        type inet:ip-address-no-zone;
                        description
                          "IP address";
                      }
                    }  // container transport-address
                  }  // container discovery

                  leaf enable {
                    type empty;
                    description
                      "Enable Address Family";
                  }

                  leaf af-name {
                    type Mpls-ldpaf-name;
                    description
                      "Address Family name";
                  }
                }  // list af
              }  // container afs

              leaf enable {
                type empty;
                description
                  "Enable Label Distribution Protocol (LDP) on
                 thisinterface";
              }

              leaf interface-name {
                type xr:Interface-name;
                description
                  "Name of interface";
              }
            }  // list interface
          }  // container interfaces

          leaf enable {
            type empty;
            description "Enable VRF";
          }

          leaf vrf-name {
            type xr:Cisco-ios-xr-string;
            description "VRF Name";
          }
        }  // list vrf
      }  // container vrfs

      container global {
        description
          "Global configuration for MPLS LDP";
        container entropy-label {
          description
            "Configure for LDP Entropy-Label";
          leaf enable {
            type empty;
            description "none";
          }
        }  // container entropy-label

        container session {
          description
            "LDP Session parameters";
          container backoff-time {
            description
              "Configure Session Backoff parameters";
            leaf initial-backoff-time {
              type uint32 {
                range "5..2147483";
              }
              units "second";
              default "15";
              description
                "Initial session backoff time (seconds)";
            }

            leaf max-backoff-time {
              type uint32 {
                range "5..2147483";
              }
              units "second";
              default "120";
              description
                "Maximum session backoff time (seconds)";
            }
          }  // container backoff-time

          leaf hold-time {
            type uint32 {
              range "15..65535";
            }
            units "second";
            default "180";
            description
              "LDP Session holdtime";
          }
        }  // container session

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

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

        container enable-logging {
          description
            "Enable logging of events";
          leaf nsr {
            type empty;
            description
              "Enable logging of NSR events";
          }

          leaf neighbor-changes {
            type empty;
            description
              "Enable logging of neighbor events";
          }

          leaf adjacency {
            type empty;
            description
              "Enable logging of adjacency events";
          }

          leaf session-protection {
            type empty;
            description
              "Enable logging of session protection events";
          }

          leaf gr-session-changes {
            type empty;
            description
              "Enable logging of Graceful Restart (GR) events";
          }
        }  // container enable-logging

        container signalling {
          description
            "Configure LDP signalling parameters";
          leaf dscp {
            type Mpls-ldp-dscp;
            default "48";
            description
              "DSCP for control packets";
          }
        }  // container signalling

        container capabilities {
          description
            "Configure LDP capabilities parameters";
          container sac {
            description
              "Configure LDP Capability State Announcement
             Control";
            leaf disable-ipv4-prefix {
              type boolean;
              default "false";
              description
                "Disable IPv4 Prefix";
            }

            leaf disable-ipv6-prefix {
              type boolean;
              default "false";
              description
                "Disable IPv6 Prefix";
            }

            leaf disable-fec128 {
              type boolean;
              default "false";
              description "Disable FEC128";
            }

            leaf disable-fec129 {
              type boolean;
              default "false";
              description "Disable FEC128";
            }
          }  // container sac
        }  // container capabilities

        container nsr {
          description
            "Configure LDP Non-Stop Routing";
          leaf enable {
            type empty;
            description "none";
          }
        }  // container nsr

        container graceful-restart {
          description
            "Configuration for LDP Graceful Restart
           parameters";
          leaf reconnect-timeout {
            type uint32 {
              range "60..1800";
            }
            units "second";
            default "120";
            description
              "Configure Graceful Restart Reconnect Timeout
             value";
          }

          leaf enable {
            type empty;
            description "none";
          }

          leaf forwarding-hold-time {
            type uint32 {
              range "60..1800";
            }
            units "second";
            default "180";
            description
              "Configure Graceful Restart Session holdtime";
          }
        }  // container graceful-restart

        container discovery {
          description
            "Configure Discovery parameters";
          container link-hello {
            description "LDP Link Hellos";
            leaf interval {
              type Mpls-ldp-interval-time;
              units "second";
              default "5";
              description
                "Link Hello interval";
            }

            leaf hold-time {
              type Mpls-ldp-hold-time;
              units "second";
              default "15";
              description
                "Time (seconds) - 65535 implies infinite";
            }
          }  // container link-hello

          container targeted-hello {
            description
              "LDP Targeted Hellos";
            leaf interval {
              type Mpls-ldp-interval-time;
              units "second";
              default "10";
              description
                "Targeted Hello interval";
            }

            leaf hold-time {
              type Mpls-ldp-hold-time;
              units "second";
              default "90";
              description
                "Time (seconds) - 65535 implies infinite";
            }
          }  // container targeted-hello

          leaf disable-instance-tlv {
            type empty;
            description
              "Disable transmit and receive processing for
             private Instance TLV in LDP discovery hello
             messages";
          }

          leaf disable-quick-start {
            type empty;
            description
              "Disable discovery's quick start mode";
          }
        }  // container discovery

        container mldp {
          description
            "MPLS mLDP configuration";
          container vrfs {
            description
              "VRF Table attribute configuration for MPLS LDP";
            list vrf {
              key "vrf-name";
              description
                "VRF attribute configuration for MPLS LDP";
              leaf vrf-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description "VRF Name";
              }

              uses ENABLE;

              uses AF-TABLE;
            }  // list vrf
          }  // container vrfs

          container default-vrf {
            description
              "Default VRF attribute configuration for mLDP";
            uses AF-TABLE;
          }  // container default-vrf

          container mldp-global {
            description
              "Global configuration for mLDP";
            container logging {
              description
                "MPLS mLDP logging";
              leaf notifications {
                type empty;
                description
                  "MPLS mLDP logging notifications";
              }
            }  // container logging
          }  // container mldp-global

          uses ENABLE;
        }  // container mldp

        container entropy-label-add-el {
          description
            "Impose Entropy Label on ELC bindings";
          leaf enable {
            type empty;
            description "none";
          }
        }  // container entropy-label-add-el

        leaf disable-implicit-ipv4 {
          type empty;
          description
            "Disable the implicit enabling for IPv4 address
           family";
        }

        leaf ltrace-buf-multiplier {
          type uint32 {
            range "1..5";
          }
          default "1";
          description
            "Configure Ltrace Buffer Multiplier";
        }
      }  // container global

      leaf enable {
        type empty;
        mandatory true;
        description
          "Enable Label Distribution Protocol (LDP)
         globally.Without creating this object the LDP
         feature will not be enabled. Deleting this
         object will stop the LDP feature.";
      }
    }  // container mpls-ldp
  }  // module Cisco-IOS-XR-mpls-ldp-cfg