module Cisco-IOS-XR-eigrp-cfg {

    yang-version 1;

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

    prefix eigrp-cfg;

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

    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 eigrp package configuration.
     
     This module contains definitions
     for the following management objects:
       eigrp: Configure Neighbor
     
     Copyright (c) 2013-2019 by Cisco Systems, Inc.
     All rights reserved.";

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

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

    revision "2018-04-05" {
      description
        "Yang support provided for config.";
    }

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

    semver:module-version "1.0.0";

    typedef Eigrp-metric-version {
      type enumeration {
        enum "64bit" {
          value 0;
          description "64-bit metrics";
        }
        enum "32bit" {
          value 1;
          description "32-bit metrics";
        }
      }
      description "Eigrp metric version";
    }

    typedef Eigrp-soo {
      type enumeration {
        enum "as" {
          value 1;
          description "AS:nn format";
        }
        enum "ipv4-address" {
          value 2;
          description
            "IPV4Address:nn format";
        }
        enum "four-byte-as" {
          value 3;
          description "AS2.AS:nn format";
        }
      }
      description "Eigrp soo";
    }

    typedef Eigrp-redist-proto {
      type enumeration {
        enum "bgp" {
          value 1;
          description "BGP routes";
        }
        enum "connected" {
          value 2;
          description "Connected routes";
        }
        enum "eigrp" {
          value 3;
          description "EIGRP routes";
        }
        enum "isis" {
          value 4;
          description "ISIS routes";
        }
        enum "ospf" {
          value 5;
          description "OSPF routes";
        }
        enum "rip" {
          value 6;
          description "RIP routes";
        }
        enum "static" {
          value 7;
          description "Static routes";
        }
        enum "ospfv3" {
          value 8;
          description "OSPFv3 routes";
        }
        enum "subscriber" {
          value 9;
          description "Subscriber routes";
        }
        enum "application" {
          value 10;
          description "Application routes";
        }
        enum "mobile" {
          value 11;
          description "Mobile routes";
        }
      }
      description "Eigrp redist proto";
    }

    typedef Eigrp-stub {
      type enumeration {
        enum "receive-only" {
          value 1;
          description "receive only";
        }
        enum "filtered" {
          value 2;
          description "filter some routes";
        }
      }
      description "Eigrp stub";
    }

    typedef Eigrp-delay-unit {
      type enumeration {
        enum "ten-microsecond" {
          value 0;
          description
            "Delay in 10's of microsecond";
        }
        enum "picosecond" {
          value 1;
          description "Delay in picosecond";
        }
      }
      description "Eigrp delay unit";
    }

    typedef Eigrp-met {
      type enumeration {
        enum "maximum-hops" {
          value 1;
          description "Metric maxhops";
        }
        enum "weights" {
          value 2;
          description "Metric weights";
        }
        enum "rib-scale" {
          value 3;
          description "Metric ribscale";
        }
        enum "version" {
          value 4;
          description "Metric version";
        }
      }
      description "Eigrp met";
    }

    typedef Eigrp-dir {
      type enumeration {
        enum "in" {
          value 1;
          description "inbound direction";
        }
        enum "out" {
          value 2;
          description "outbound direction";
        }
      }
      description "Eigrp dir";
    }

    typedef Eigrp-timer {
      type enumeration {
        enum "active" {
          value 1;
          description "Active time";
        }
        enum "route-hold" {
          value 2;
          description "Route-hold time";
        }
        enum "signal" {
          value 3;
          description "Signal time";
        }
        enum "converge" {
          value 4;
          description "Converge time";
        }
      }
      description "Eigrp timer";
    }

    container eigrp {
      description "Configure Neighbor";
      container processes {
        description
          "Process related configuration";
        list process {
          key "process-id";
          description
            "Configuration for a particular EIGRP process.";
          container vrfs {
            description "List of VRFs";
            list vrf {
              key "vrf-name";
              description
                "Non-default VRF configuration.Deletion of
               this object also causes deletion of all
               objectsunder 'VRF' associated with this VRF
               instance.";
              container afs {
                description
                  "Address family list in a VRF";
                list af {
                  key "af-name";
                  description
                    "Configuration under an AF in a non-default
                   VRF context.Deletion of this object also
                   causes deletion of all objectsunder 'AF'
                   associated with this AF instance.";
                  container all-neighbors-maximum-prefix {
                    description
                      "Maximum number of IP prefixes acceptable
                     in aggregate, from neighbors";
                    leaf max-prefix {
                      type uint32 {
                        range
                          "1..4294967295";
                      }
                      description
                        "Number of IP prefixes for maximum-prefix
                       limit";
                    }

                    leaf threshold {
                      type uint32 {
                        range "1..100";
                      }
                      units "percentage";
                      description
                        "Configure threshold percentage for
                       warnings";
                    }

                    leaf dampened {
                      type boolean;
                      description
                        "Enable decay penalty to be applied to
                       time period";
                    }

                    leaf reset-time {
                      type uint32;
                      description
                        "Time to reset restart count";
                    }

                    leaf restart {
                      type uint32;
                      description
                        "Shutdown time after hitting max-prefix
                       limit";
                    }

                    leaf restart-count {
                      type uint32;
                      description
                        "Restart count after hitting max-prefix
                       limit";
                    }

                    leaf warning-only {
                      type boolean;
                      description
                        "Only a warning is logged when prefix
                       limit is reached";
                    }
                  }  // container all-neighbors-maximum-prefix

                  container redist-maximum-prefix {
                    description
                      "Maximum number of prefixes redistributed
                     to protocol";
                    leaf max-prefix {
                      type uint32 {
                        range
                          "1..4294967295";
                      }
                      description
                        "Number of IP prefixes for maximum-prefix
                       limit";
                    }

                    leaf threshold {
                      type uint32 {
                        range "1..100";
                      }
                      units "percentage";
                      description
                        "Configure threshold percentage for
                       warnings";
                    }

                    leaf dampened {
                      type uint32;
                      description
                        "Enable decay penalty to be applied to
                       time period";
                    }

                    leaf reset-time {
                      type uint32;
                      description
                        "Time to reset restart count";
                    }

                    leaf restart {
                      type uint32;
                      description
                        "Shutdown time after hitting max-prefix
                       limit";
                    }

                    leaf restart-count {
                      type uint32;
                      description
                        "Restart count after hitting max-prefix
                       limit";
                    }

                    leaf warning-only {
                      type boolean;
                      description
                        "Only a warning is logged when prefix
                       limit is reached";
                    }
                  }  // container redist-maximum-prefix

                  container neighbor-maximum-prefixes {
                    description
                      "List of neighbors with prefix limits";
                    list neighbor-maximum-prefix {
                      key "neighbor-address";
                      description
                        "Neighbor prefix limits configuration";
                      leaf neighbor-address {
                        type inet:ip-address-no-zone;
                        description
                          "Neighbor IP address";
                      }

                      leaf max-prefix {
                        type uint32 {
                          range
                            "1..4294967295";
                        }
                        description
                          "Number of IP prefixes for maximum-prefix
                         limit";
                      }

                      leaf threshold {
                        type uint32 {
                          range "1..100";
                        }
                        units "percentage";
                        description
                          "Configure threshold percentage for
                         warnings";
                      }

                      leaf warning-only {
                        type boolean;
                        description
                          "Only a warning is logged when prefix
                         limit is reached";
                      }
                    }  // list neighbor-maximum-prefix
                  }  // container neighbor-maximum-prefixes

                  container maximum-prefix {
                    description
                      "Maximum number of IP prefixes acceptable
                     in aggregate";
                    leaf max-prefix {
                      type uint32 {
                        range
                          "1..4294967295";
                      }
                      description
                        "Number of IP prefixes for maximum-prefix
                       limit";
                    }

                    leaf threshold {
                      type uint32 {
                        range "1..100";
                      }
                      units "percentage";
                      description
                        "Configure threshold percentage for
                       warnings";
                    }

                    leaf dampened {
                      type boolean;
                      description
                        "Enable decay penalty to be applied to
                       time period";
                    }

                    leaf reset-time {
                      type uint32;
                      description
                        "Time to reset restart count";
                    }

                    leaf restart {
                      type uint32;
                      description
                        "Shutdown time after hitting max-prefix
                       limit";
                    }

                    leaf restart-count {
                      type uint32;
                      description
                        "Restart count after hitting max-prefix
                       limit";
                    }

                    leaf warning-only {
                      type boolean;
                      description
                        "Only a warning is logged when prefix
                       limit is reached";
                    }
                  }  // container maximum-prefix

                  leaf enable {
                    type empty;
                    description
                      "Enable an Address Family under a
                     non-default VRF";
                  }

                  leaf af-name {
                    type dt1:Eigrp-af;
                    description
                      "Address Family";
                  }

                  leaf auto-summary {
                    type empty;
                    description
                      "Enable Auto Summarization";
                  }

                  container stub {
                    presence "enable stub";
                    description
                      "EIGRP stub configuration";
                    leaf type {
                      type Eigrp-stub;
                      description
                        "Stub config type";
                    }

                    leaf connected {
                      type boolean;
                      description
                        "Do advertise connected routes";
                    }

                    leaf redistributed {
                      type boolean;
                      description
                        "Do advertise redistributed routes";
                    }

                    leaf static {
                      type boolean;
                      description
                        "Do advertise static routes";
                    }

                    leaf summary {
                      type boolean;
                      description
                        "Do advertise summary routes";
                    }
                  }  // container stub

                  leaf maximum-paths {
                    type uint32 {
                      range "1..32";
                    }
                    description
                      "number of paths";
                  }

                  container redistributes {
                    presence
                      "Indicates a redistributes node is configured.";
                    description
                      "List of redistributed protocols";
                    list redistribute {
                      key "protocol-name";
                      description
                        "Redistribute another protocol";
                      leaf protocol-name {
                        type Eigrp-redist-proto;
                        description
                          "Redistributed protocol";
                      }

                      leaf policy-name {
                        type string;
                        description
                          "Policy name";
                      }

                      leaf policy-specified {
                        type boolean;
                        mandatory true;
                        description
                          "TRUE if Policy has been specified";
                      }
                    }  // list redistribute

                    list redistribute-as-xx {
                      key "as-xx protocol-name";
                      description
                        "Redistribute another protocol";
                      leaf as-xx {
                        type uint32 {
                          range "0..65535";
                        }
                        description
                          "Higher sixteen bits of 4-byte BGP AS number";
                      }

                      leaf protocol-name {
                        type Eigrp-redist-proto;
                        description
                          "Redistributed protocol";
                      }

                      leaf policy-name {
                        type string;
                        description
                          "Policy name";
                      }

                      leaf policy-specified {
                        type boolean;
                        mandatory true;
                        description
                          "TRUE if Policy has been specified";
                      }
                    }  // list redistribute-as-xx

                    list redistribute-as-yy {
                      key "as-yy protocol-name";
                      description
                        "Redistribute another protocol";
                      leaf as-yy {
                        type uint32 {
                          range
                            "0..4294967295";
                        }
                        description
                          "2-byte or 4-byte BGP AS Number";
                      }

                      leaf protocol-name {
                        type Eigrp-redist-proto;
                        description
                          "Redistributed protocol";
                      }

                      leaf policy-name {
                        type string;
                        description
                          "Policy name";
                      }

                      leaf policy-specified {
                        type boolean;
                        mandatory true;
                        description
                          "TRUE if Policy has been specified";
                      }
                    }  // list redistribute-as-yy

                    list redistribute-as-xx-as-yy {
                      key "as-xx as-yy protocol-name";
                      description
                        "Redistribute another protocol";
                      leaf as-xx {
                        type uint32 {
                          range "0..65535";
                        }
                        description
                          "Higher sixteen bits of 4-byte BGP AS number";
                      }

                      leaf as-yy {
                        type uint32 {
                          range
                            "0..4294967295";
                        }
                        description
                          "2-byte or 4-byte BGP AS Number";
                      }

                      leaf protocol-name {
                        type Eigrp-redist-proto;
                        description
                          "Redistributed protocol";
                      }

                      leaf policy-name {
                        type string;
                        description
                          "Policy name";
                      }

                      leaf policy-specified {
                        type boolean;
                        mandatory true;
                        description
                          "TRUE if Policy has been specified";
                      }
                    }  // list redistribute-as-xx-as-yy

                    list redistribute-tag-name {
                      key "tag-name protocol-name";
                      description
                        "Redistribute another protocol";
                      leaf tag-name {
                        type xr:Cisco-ios-xr-string;
                        description
                          "OSPF/OSPFv3/ISIS/OnePK Application tag name";
                      }

                      leaf protocol-name {
                        type Eigrp-redist-proto;
                        description
                          "Redistributed protocol";
                      }

                      leaf policy-name {
                        type string;
                        description
                          "Policy name";
                      }

                      leaf policy-specified {
                        type boolean;
                        mandatory true;
                        description
                          "TRUE if Policy has been specified";
                      }
                    }  // list redistribute-tag-name

                    list redistribute-as-xx-tag-name {
                      key "as-xx tag-name protocol-name";
                      description
                        "Redistribute another protocol";
                      leaf as-xx {
                        type uint32 {
                          range "0..65535";
                        }
                        description
                          "Higher sixteen bits of 4-byte BGP AS number";
                      }

                      leaf tag-name {
                        type xr:Cisco-ios-xr-string;
                        description
                          "OSPF/OSPFv3/ISIS/OnePK Application tag name";
                      }

                      leaf protocol-name {
                        type Eigrp-redist-proto;
                        description
                          "Redistributed protocol";
                      }

                      leaf policy-name {
                        type string;
                        description
                          "Policy name";
                      }

                      leaf policy-specified {
                        type boolean;
                        mandatory true;
                        description
                          "TRUE if Policy has been specified";
                      }
                    }  // list redistribute-as-xx-tag-name

                    list redistribute-as-yy-tag-name {
                      key "as-yy tag-name protocol-name";
                      description
                        "Redistribute another protocol";
                      leaf as-yy {
                        type uint32 {
                          range
                            "0..4294967295";
                        }
                        description
                          "2-byte or 4-byte BGP AS Number";
                      }

                      leaf tag-name {
                        type xr:Cisco-ios-xr-string;
                        description
                          "OSPF/OSPFv3/ISIS/OnePK Application tag name";
                      }

                      leaf protocol-name {
                        type Eigrp-redist-proto;
                        description
                          "Redistributed protocol";
                      }

                      leaf policy-name {
                        type string;
                        description
                          "Policy name";
                      }

                      leaf policy-specified {
                        type boolean;
                        mandatory true;
                        description
                          "TRUE if Policy has been specified";
                      }
                    }  // list redistribute-as-yy-tag-name

                    list redistribute-as-xx-as-yy-tag-name {
                      key "as-xx as-yy tag-name protocol-name";
                      description
                        "Redistribute another protocol";
                      leaf as-xx {
                        type uint32 {
                          range "0..65535";
                        }
                        description
                          "Higher sixteen bits of 4-byte BGP AS number";
                      }

                      leaf as-yy {
                        type uint32 {
                          range
                            "0..4294967295";
                        }
                        description
                          "2-byte or 4-byte BGP AS Number";
                      }

                      leaf tag-name {
                        type xr:Cisco-ios-xr-string;
                        description
                          "OSPF/OSPFv3/ISIS/OnePK Application tag name";
                      }

                      leaf protocol-name {
                        type Eigrp-redist-proto;
                        description
                          "Redistributed protocol";
                      }

                      leaf policy-name {
                        type string;
                        description
                          "Policy name";
                      }

                      leaf policy-specified {
                        type boolean;
                        mandatory true;
                        description
                          "TRUE if Policy has been specified";
                      }
                    }  // list redistribute-as-xx-as-yy-tag-name
                  }  // container redistributes

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

                  leaf log-neighbor-warnings {
                    type empty;
                    description
                      "Enable/Disable neighbor state change warnings ";
                  }

                  container filter-policies {
                    description
                      "Inbound and outbound filter policies";
                    list filter-policy {
                      key "direction";
                      description
                        "Inbound/outbound policies";
                      leaf direction {
                        type Eigrp-dir;
                        description
                          "Direction (in or out)";
                      }

                      leaf policy-name {
                        type string;
                        mandatory true;
                        description
                          "Policy name";
                      }
                    }  // list filter-policy
                  }  // container filter-policies

                  container default-metric {
                    description
                      "Set metric of redistributed routes";
                    leaf bandwidth {
                      type uint32 {
                        range
                          "1..4294967295";
                      }
                      units "kbit/s";
                      description
                        "Bandwidth in Kbits per second";
                    }

                    leaf delay {
                      type uint32 {
                        range
                          "1..4294967295";
                      }
                      description
                        "Delay metric, in 10 microsecond units";
                    }

                    leaf reliability {
                      type uint32 {
                        range "0..255";
                      }
                      description
                        "Reliability metric where 255 is 100% reliable";
                    }

                    leaf load {
                      type uint32 {
                        range "1..255";
                      }
                      description
                        "Effective bandwidth metric (Loading) where 255
is 100% loaded";
                    }

                    leaf mtu {
                      type uint32 {
                        range "1..65535";
                      }
                      description
                        "Maximum Transmission Unit metric of the path";
                    }
                  }  // container default-metric

                  leaf autonomous-system {
                    type uint32 {
                      range "1..65535";
                    }
                    description
                      "Set the autonomous system of a VRF";
                  }

                  leaf variance {
                    type uint32 {
                      range "1..128";
                    }
                    description
                      "Control load balancing variance";
                  }

                  container metrics {
                    description
                      "List of metric change behaviours";
                    list metric {
                      key "metric-name";
                      description
                        "Modify EIGRP routing metrics and parameters";
                      leaf metric-name {
                        type Eigrp-met;
                        description
                          "Type of metric change";
                      }

                      leaf max-hops {
                        type uint32 {
                          range "1..255";
                        }
                        description
                          "Hop count";
                      }

                      leaf tos {
                        type uint32 {
                          range "0";
                        }
                        description
                          "Type of Service (Only TOS 0 supported)";
                      }

                      leaf k1 {
                        type uint32 {
                          range "0..255";
                        }
                        description "K1";
                      }

                      leaf k2 {
                        type uint32 {
                          range "0..255";
                        }
                        description "K2";
                      }

                      leaf k3 {
                        type uint32 {
                          range "0..255";
                        }
                        description "K3";
                      }

                      leaf k4 {
                        type uint32 {
                          range "0..255";
                        }
                        description "K4";
                      }

                      leaf k5 {
                        type uint32 {
                          range "0..255";
                        }
                        description "K5";
                      }

                      leaf k6 {
                        type uint32 {
                          range "0..255";
                        }
                        description "K6";
                      }

                      leaf rib-scale {
                        type uint32 {
                          range
                            "1..4294967295";
                        }
                        description
                          "RIB scale";
                      }

                      leaf metric-version {
                        type Eigrp-metric-version;
                        description
                          "Metric version";
                      }
                    }  // list metric
                  }  // container metrics

                  container timers {
                    description
                      "List of timer configurations";
                    list timer {
                      key "timer-type";
                      description
                        "Configure EIGRP timers";
                      leaf timer-type {
                        type Eigrp-timer;
                        description
                          "Type of timer";
                      }

                      leaf active-time {
                        type uint32;
                        units "second";
                        description
                          "Active Time (in seconds)";
                      }

                      leaf hold-time {
                        type uint32 {
                          range "20..6000";
                        }
                        units "second";
                        description
                          "Hold time (in seconds)";
                      }

                      leaf signal-time {
                        type uint32 {
                          range "10..30";
                        }
                        units "second";
                        description
                          "Signal time (in seconds)";
                      }

                      leaf converge-time {
                        type uint32 {
                          range "60..5000";
                        }
                        units "second";
                        description
                          "Converge time (in seconds)";
                      }
                    }  // list timer
                  }  // container timers

                  leaf nsf-disable {
                    type empty;
                    description
                      "Disable NSF for this address family under this
VRF";
                  }

                  container default-accepts {
                    description
                      "Candidate default policy table";
                    list default-accept {
                      key "direction";
                      description
                        "Candidate default behaviour";
                      leaf direction {
                        type Eigrp-dir;
                        description
                          "Direction (in or out)";
                      }

                      leaf policy-name {
                        type string;
                        description
                          "Policy name";
                      }

                      leaf policy-specified {
                        type boolean;
                        mandatory true;
                        description
                          "TRUE if Policy has been specified";
                      }
                    }  // list default-accept
                  }  // container default-accepts

                  leaf passive-interface-default {
                    type empty;
                    description
                      "Suppress routing updates on all interfaces";
                  }

                  container interfaces {
                    description
                      "List of interfaces";
                    list interface {
                      key "interface-name";
                      description
                        "Configuration for an Interface.Deletion of this
object also causes deletion of all objectsunder
'Interface' associated with this interface
instance.";
                      container interface-metric {
                        description "Metric";
                        leaf bandwidth {
                          type uint32 {
                            range
                              "1..4294967295";
                          }
                          units "kbit/s";
                          description
                            "Bandwidth in Kbits per second";
                        }

                        leaf delay {
                          type uint32 {
                            range
                              "1..4294967295";
                          }
                          description
                            "Delay metric, in 10 microsecond units
(default) or picosecond units";
                        }

                        leaf delay-unit {
                          type Eigrp-delay-unit;
                          description
                            "Delay unit";
                        }

                        leaf reliability {
                          type uint32 {
                            range "0..255";
                          }
                          description
                            "Reliability metric where 255 is 100% reliable";
                        }

                        leaf load {
                          type uint32 {
                            range "1..255";
                          }
                          description
                            "Effective bandwidth metric (Loading) where
255 is 100% loaded";
                        }
                      }  // container interface-metric

                      container remote-neighbor {
                        presence
                          "Indicates a remote-neighbor node is configured.";
                        description
                          "Remote-Neighbors enabled, default is 65535";
                        leaf enable {
                          type boolean;
                          mandatory true;
                          description
                            "Enable Remote neighbor unicast-listen";
                        }

                        leaf allow-list {
                          type string;
                          description
                            "Policy name";
                        }

                        leaf max-neighbors {
                          type uint32 {
                            range "1..65535";
                          }
                          description
                            "Neighbor count";
                        }
                      }  // container remote-neighbor

                      container bfd {
                        description
                          "Configure BFD parameters";
                        leaf fast-detect {
                          type boolean;
                          description
                            "Enable BFD fast detection";
                        }

                        leaf detection-multiplier {
                          type uint32 {
                            range "2..50";
                          }
                          description
                            "Detect multiplier";
                        }

                        leaf interval {
                          type uint32 {
                            range "15..3000";
                          }
                          units
                            "millisecond";
                          description
                            "Hello interval in milli-seconds";
                        }
                      }  // container bfd

                      container site-of-origin {
                        description
                          "Configure Site-of-origin";
                        leaf type {
                          type Eigrp-soo;
                          description
                            "SoO type";
                        }

                        leaf as-xx {
                          type uint32 {
                            range "0..65535";
                          }
                          description
                            "Higher sixteen bits of 4-byte BGP AS Number";
                        }

                        leaf as-yy {
                          type uint32 {
                            range
                              "0..4294967295";
                          }
                          description
                            "2-byte or 4-byte BGP AS Number";
                        }

                        leaf index {
                          type uint32 {
                            range
                              "0..4294967295";
                          }
                          description
                            "AS Number Index";
                        }

                        leaf address {
                          type inet:ipv4-address-no-zone;
                          description
                            "IPv4 address";
                        }

                        leaf address-index {
                          type uint32 {
                            range "0..65535";
                          }
                          description
                            "IPv4 address index";
                        }
                      }  // container site-of-origin

                      container authentication {
                        description
                          "Authentication configuration";
                        leaf keychain {
                          type string;
                          description
                            "Authentication keychain configuration";
                        }
                      }  // container authentication

                      container summary-addresses {
                        description
                          "List of summary addresses under this interface";
                        list summary-address {
                          key "summary-address-addr summary-address-prefix";
                          description
                            "Summary address";
                          leaf summary-address-addr {
                            type inet:ip-address;
                            description
                              "Summary Prefix (address part)";
                          }

                          leaf summary-address-prefix {
                            type uint16 {
                              range "0..128";
                            }
                            description
                              "Summary Prefix (prefix part)";
                          }

                          leaf distance {
                            type uint32 {
                              range "1..255";
                            }
                            mandatory true;
                            description
                              "Administrative distance";
                          }
                        }  // list summary-address
                      }  // container summary-addresses

                      container interface-filter-policies {
                        description
                          "List of filter policies";
                        list interface-filter-policy {
                          key "direction";
                          description "none";
                          leaf direction {
                            type Eigrp-dir;
                            description
                              "Direction (in or out)";
                          }

                          leaf policy-name {
                            type string;
                            mandatory true;
                            description
                              "Policy name";
                          }
                        }  // list interface-filter-policy
                      }  // container interface-filter-policies

                      container interface-static-neighbors {
                        description
                          "List of Neighbors";
                        list interface-static-neighbor {
                          key "neighbor-address";
                          description
                            "Configure Neighbor";
                          leaf neighbor-address {
                            type inet:ip-address-no-zone;
                            description
                              "Neighbor IP address";
                          }

                          leaf max-hops {
                            type uint32 {
                              range "2..100";
                            }
                            mandatory true;
                            description
                              "Number of hops";
                          }
                        }  // list interface-static-neighbor
                      }  // container interface-static-neighbors

                      leaf hold-time {
                        type uint32 {
                          range "1..65535";
                        }
                        units "second";
                        description
                          "Neighbor hold time (in seconds)";
                      }

                      leaf bandwidth-percent {
                        type uint32 {
                          range "1..999999";
                        }
                        units "percentage";
                        description
                          "Bandwidth limit";
                      }

                      leaf passive-interface {
                        type boolean;
                        description
                          "Suppress routing updates on an interface";
                      }

                      leaf hello-interval {
                        type uint32 {
                          range "1..65535";
                        }
                        units "second";
                        description
                          "Interval (in seconds)";
                      }

                      leaf next-hop-self {
                        type empty;
                        description
                          "Disable next-hop-self";
                      }

                      leaf enable {
                        type empty;
                        description
                          "Enable Interface configuration";
                      }

                      leaf split-horizon {
                        type empty;
                        description
                          "Configure split horizon behaviour";
                      }

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

                  container distance {
                    description
                      "Set distance for EIGRP routes";
                    leaf internal-distance {
                      type uint32 {
                        range "1..255";
                      }
                      description
                        "Internal routes' distance";
                    }

                    leaf external-distance {
                      type uint32 {
                        range "1..255";
                      }
                      description
                        "External routes' distance";
                    }
                  }  // container distance

                  leaf log-neighbor-changes {
                    type empty;
                    description
                      "Enable/Disable logginf of neighbor state changes";
                  }
                }  // list af
              }  // container afs

              leaf enable {
                type empty;
                description
                  "Enable a non-default VRF under the EIGRP
                 process";
              }

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

          container default-vrf {
            description
              "Default VRF configuration.Deletion of this
             object also causes deletion of all
             objectsunder 'Process' associated with this
             process instance.";
            container default-afs {
              description
                "Address family list in the default context";
              list default-af {
                key "af-name";
                description
                  "Configuration under an AF in the default
                 context.Deletion of this object also causes
                 deletion of all objectsunder 'DefaultAF'
                 associated with this AF instance.";
                leaf enable {
                  type empty;
                  description
                    "Enable an Address Family under a default
                   VRF";
                }

                leaf af-name {
                  type dt1:Eigrp-af;
                  description
                    "Address Family";
                }

                leaf auto-summary {
                  type empty;
                  description
                    "Enable Auto Summarization";
                }

                container stub {
                  presence "enable stub";
                  description
                    "EIGRP stub configuration";
                  leaf type {
                    type Eigrp-stub;
                    description
                      "Stub config type";
                  }

                  leaf connected {
                    type boolean;
                    description
                      "Do advertise connected routes";
                  }

                  leaf redistributed {
                    type boolean;
                    description
                      "Do advertise redistributed routes";
                  }

                  leaf static {
                    type boolean;
                    description
                      "Do advertise static routes";
                  }

                  leaf summary {
                    type boolean;
                    description
                      "Do advertise summary routes";
                  }
                }  // container stub

                leaf maximum-paths {
                  type uint32 {
                    range "1..32";
                  }
                  description
                    "number of paths";
                }

                container redistributes {
                  presence
                    "Indicates a redistributes node is configured.";
                  description
                    "List of redistributed protocols";
                  list redistribute {
                    key "protocol-name";
                    description
                      "Redistribute another protocol";
                    leaf protocol-name {
                      type Eigrp-redist-proto;
                      description
                        "Redistributed protocol";
                    }

                    leaf policy-name {
                      type string;
                      description
                        "Policy name";
                    }

                    leaf policy-specified {
                      type boolean;
                      mandatory true;
                      description
                        "TRUE if Policy has been specified";
                    }
                  }  // list redistribute

                  list redistribute-as-xx {
                    key "as-xx protocol-name";
                    description
                      "Redistribute another protocol";
                    leaf as-xx {
                      type uint32 {
                        range "0..65535";
                      }
                      description
                        "Higher sixteen bits of 4-byte BGP AS number";
                    }

                    leaf protocol-name {
                      type Eigrp-redist-proto;
                      description
                        "Redistributed protocol";
                    }

                    leaf policy-name {
                      type string;
                      description
                        "Policy name";
                    }

                    leaf policy-specified {
                      type boolean;
                      mandatory true;
                      description
                        "TRUE if Policy has been specified";
                    }
                  }  // list redistribute-as-xx

                  list redistribute-as-yy {
                    key "as-yy protocol-name";
                    description
                      "Redistribute another protocol";
                    leaf as-yy {
                      type uint32 {
                        range
                          "0..4294967295";
                      }
                      description
                        "2-byte or 4-byte BGP AS Number";
                    }

                    leaf protocol-name {
                      type Eigrp-redist-proto;
                      description
                        "Redistributed protocol";
                    }

                    leaf policy-name {
                      type string;
                      description
                        "Policy name";
                    }

                    leaf policy-specified {
                      type boolean;
                      mandatory true;
                      description
                        "TRUE if Policy has been specified";
                    }
                  }  // list redistribute-as-yy

                  list redistribute-as-xx-as-yy {
                    key "as-xx as-yy protocol-name";
                    description
                      "Redistribute another protocol";
                    leaf as-xx {
                      type uint32 {
                        range "0..65535";
                      }
                      description
                        "Higher sixteen bits of 4-byte BGP AS number";
                    }

                    leaf as-yy {
                      type uint32 {
                        range
                          "0..4294967295";
                      }
                      description
                        "2-byte or 4-byte BGP AS Number";
                    }

                    leaf protocol-name {
                      type Eigrp-redist-proto;
                      description
                        "Redistributed protocol";
                    }

                    leaf policy-name {
                      type string;
                      description
                        "Policy name";
                    }

                    leaf policy-specified {
                      type boolean;
                      mandatory true;
                      description
                        "TRUE if Policy has been specified";
                    }
                  }  // list redistribute-as-xx-as-yy

                  list redistribute-tag-name {
                    key "tag-name protocol-name";
                    description
                      "Redistribute another protocol";
                    leaf tag-name {
                      type xr:Cisco-ios-xr-string;
                      description
                        "OSPF/OSPFv3/ISIS/OnePK Application tag name";
                    }

                    leaf protocol-name {
                      type Eigrp-redist-proto;
                      description
                        "Redistributed protocol";
                    }

                    leaf policy-name {
                      type string;
                      description
                        "Policy name";
                    }

                    leaf policy-specified {
                      type boolean;
                      mandatory true;
                      description
                        "TRUE if Policy has been specified";
                    }
                  }  // list redistribute-tag-name

                  list redistribute-as-xx-tag-name {
                    key "as-xx tag-name protocol-name";
                    description
                      "Redistribute another protocol";
                    leaf as-xx {
                      type uint32 {
                        range "0..65535";
                      }
                      description
                        "Higher sixteen bits of 4-byte BGP AS number";
                    }

                    leaf tag-name {
                      type xr:Cisco-ios-xr-string;
                      description
                        "OSPF/OSPFv3/ISIS/OnePK Application tag name";
                    }

                    leaf protocol-name {
                      type Eigrp-redist-proto;
                      description
                        "Redistributed protocol";
                    }

                    leaf policy-name {
                      type string;
                      description
                        "Policy name";
                    }

                    leaf policy-specified {
                      type boolean;
                      mandatory true;
                      description
                        "TRUE if Policy has been specified";
                    }
                  }  // list redistribute-as-xx-tag-name

                  list redistribute-as-yy-tag-name {
                    key "as-yy tag-name protocol-name";
                    description
                      "Redistribute another protocol";
                    leaf as-yy {
                      type uint32 {
                        range
                          "0..4294967295";
                      }
                      description
                        "2-byte or 4-byte BGP AS Number";
                    }

                    leaf tag-name {
                      type xr:Cisco-ios-xr-string;
                      description
                        "OSPF/OSPFv3/ISIS/OnePK Application tag name";
                    }

                    leaf protocol-name {
                      type Eigrp-redist-proto;
                      description
                        "Redistributed protocol";
                    }

                    leaf policy-name {
                      type string;
                      description
                        "Policy name";
                    }

                    leaf policy-specified {
                      type boolean;
                      mandatory true;
                      description
                        "TRUE if Policy has been specified";
                    }
                  }  // list redistribute-as-yy-tag-name

                  list redistribute-as-xx-as-yy-tag-name {
                    key "as-xx as-yy tag-name protocol-name";
                    description
                      "Redistribute another protocol";
                    leaf as-xx {
                      type uint32 {
                        range "0..65535";
                      }
                      description
                        "Higher sixteen bits of 4-byte BGP AS number";
                    }

                    leaf as-yy {
                      type uint32 {
                        range
                          "0..4294967295";
                      }
                      description
                        "2-byte or 4-byte BGP AS Number";
                    }

                    leaf tag-name {
                      type xr:Cisco-ios-xr-string;
                      description
                        "OSPF/OSPFv3/ISIS/OnePK Application tag name";
                    }

                    leaf protocol-name {
                      type Eigrp-redist-proto;
                      description
                        "Redistributed protocol";
                    }

                    leaf policy-name {
                      type string;
                      description
                        "Policy name";
                    }

                    leaf policy-specified {
                      type boolean;
                      mandatory true;
                      description
                        "TRUE if Policy has been specified";
                    }
                  }  // list redistribute-as-xx-as-yy-tag-name
                }  // container redistributes

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

                leaf log-neighbor-warnings {
                  type empty;
                  description
                    "Enable/Disable neighbor state change warnings ";
                }

                container filter-policies {
                  description
                    "Inbound and outbound filter policies";
                  list filter-policy {
                    key "direction";
                    description
                      "Inbound/outbound policies";
                    leaf direction {
                      type Eigrp-dir;
                      description
                        "Direction (in or out)";
                    }

                    leaf policy-name {
                      type string;
                      mandatory true;
                      description
                        "Policy name";
                    }
                  }  // list filter-policy
                }  // container filter-policies

                container default-metric {
                  description
                    "Set metric of redistributed routes";
                  leaf bandwidth {
                    type uint32 {
                      range "1..4294967295";
                    }
                    units "kbit/s";
                    description
                      "Bandwidth in Kbits per second";
                  }

                  leaf delay {
                    type uint32 {
                      range "1..4294967295";
                    }
                    description
                      "Delay metric, in 10 microsecond units";
                  }

                  leaf reliability {
                    type uint32 {
                      range "0..255";
                    }
                    description
                      "Reliability metric where 255 is 100% reliable";
                  }

                  leaf load {
                    type uint32 {
                      range "1..255";
                    }
                    description
                      "Effective bandwidth metric (Loading) where 255
is 100% loaded";
                  }

                  leaf mtu {
                    type uint32 {
                      range "1..65535";
                    }
                    description
                      "Maximum Transmission Unit metric of the path";
                  }
                }  // container default-metric

                leaf autonomous-system {
                  type uint32 {
                    range "1..65535";
                  }
                  description
                    "Set the autonomous system of a VRF";
                }

                leaf variance {
                  type uint32 {
                    range "1..128";
                  }
                  description
                    "Control load balancing variance";
                }

                container metrics {
                  description
                    "List of metric change behaviours";
                  list metric {
                    key "metric-name";
                    description
                      "Modify EIGRP routing metrics and parameters";
                    leaf metric-name {
                      type Eigrp-met;
                      description
                        "Type of metric change";
                    }

                    leaf max-hops {
                      type uint32 {
                        range "1..255";
                      }
                      description
                        "Hop count";
                    }

                    leaf tos {
                      type uint32 {
                        range "0";
                      }
                      description
                        "Type of Service (Only TOS 0 supported)";
                    }

                    leaf k1 {
                      type uint32 {
                        range "0..255";
                      }
                      description "K1";
                    }

                    leaf k2 {
                      type uint32 {
                        range "0..255";
                      }
                      description "K2";
                    }

                    leaf k3 {
                      type uint32 {
                        range "0..255";
                      }
                      description "K3";
                    }

                    leaf k4 {
                      type uint32 {
                        range "0..255";
                      }
                      description "K4";
                    }

                    leaf k5 {
                      type uint32 {
                        range "0..255";
                      }
                      description "K5";
                    }

                    leaf k6 {
                      type uint32 {
                        range "0..255";
                      }
                      description "K6";
                    }

                    leaf rib-scale {
                      type uint32 {
                        range
                          "1..4294967295";
                      }
                      description
                        "RIB scale";
                    }

                    leaf metric-version {
                      type Eigrp-metric-version;
                      description
                        "Metric version";
                    }
                  }  // list metric
                }  // container metrics

                container timers {
                  description
                    "List of timer configurations";
                  list timer {
                    key "timer-type";
                    description
                      "Configure EIGRP timers";
                    leaf timer-type {
                      type Eigrp-timer;
                      description
                        "Type of timer";
                    }

                    leaf active-time {
                      type uint32;
                      units "second";
                      description
                        "Active Time (in seconds)";
                    }

                    leaf hold-time {
                      type uint32 {
                        range "20..6000";
                      }
                      units "second";
                      description
                        "Hold time (in seconds)";
                    }

                    leaf signal-time {
                      type uint32 {
                        range "10..30";
                      }
                      units "second";
                      description
                        "Signal time (in seconds)";
                    }

                    leaf converge-time {
                      type uint32 {
                        range "60..5000";
                      }
                      units "second";
                      description
                        "Converge time (in seconds)";
                    }
                  }  // list timer
                }  // container timers

                leaf nsf-disable {
                  type empty;
                  description
                    "Disable NSF for this address family under this
VRF";
                }

                container default-accepts {
                  description
                    "Candidate default policy table";
                  list default-accept {
                    key "direction";
                    description
                      "Candidate default behaviour";
                    leaf direction {
                      type Eigrp-dir;
                      description
                        "Direction (in or out)";
                    }

                    leaf policy-name {
                      type string;
                      description
                        "Policy name";
                    }

                    leaf policy-specified {
                      type boolean;
                      mandatory true;
                      description
                        "TRUE if Policy has been specified";
                    }
                  }  // list default-accept
                }  // container default-accepts

                leaf passive-interface-default {
                  type empty;
                  description
                    "Suppress routing updates on all interfaces";
                }

                container interfaces {
                  description
                    "List of interfaces";
                  list interface {
                    key "interface-name";
                    description
                      "Configuration for an Interface.Deletion of this
object also causes deletion of all objectsunder
'Interface' associated with this interface
instance.";
                    container interface-metric {
                      description "Metric";
                      leaf bandwidth {
                        type uint32 {
                          range
                            "1..4294967295";
                        }
                        units "kbit/s";
                        description
                          "Bandwidth in Kbits per second";
                      }

                      leaf delay {
                        type uint32 {
                          range
                            "1..4294967295";
                        }
                        description
                          "Delay metric, in 10 microsecond units
(default) or picosecond units";
                      }

                      leaf delay-unit {
                        type Eigrp-delay-unit;
                        description
                          "Delay unit";
                      }

                      leaf reliability {
                        type uint32 {
                          range "0..255";
                        }
                        description
                          "Reliability metric where 255 is 100% reliable";
                      }

                      leaf load {
                        type uint32 {
                          range "1..255";
                        }
                        description
                          "Effective bandwidth metric (Loading) where
255 is 100% loaded";
                      }
                    }  // container interface-metric

                    container remote-neighbor {
                      presence
                        "Indicates a remote-neighbor node is configured.";
                      description
                        "Remote-Neighbors enabled, default is 65535";
                      leaf enable {
                        type boolean;
                        mandatory true;
                        description
                          "Enable Remote neighbor unicast-listen";
                      }

                      leaf allow-list {
                        type string;
                        description
                          "Policy name";
                      }

                      leaf max-neighbors {
                        type uint32 {
                          range "1..65535";
                        }
                        description
                          "Neighbor count";
                      }
                    }  // container remote-neighbor

                    container bfd {
                      description
                        "Configure BFD parameters";
                      leaf fast-detect {
                        type boolean;
                        description
                          "Enable BFD fast detection";
                      }

                      leaf detection-multiplier {
                        type uint32 {
                          range "2..50";
                        }
                        description
                          "Detect multiplier";
                      }

                      leaf interval {
                        type uint32 {
                          range "15..3000";
                        }
                        units "millisecond";
                        description
                          "Hello interval in milli-seconds";
                      }
                    }  // container bfd

                    container site-of-origin {
                      description
                        "Configure Site-of-origin";
                      leaf type {
                        type Eigrp-soo;
                        description
                          "SoO type";
                      }

                      leaf as-xx {
                        type uint32 {
                          range "0..65535";
                        }
                        description
                          "Higher sixteen bits of 4-byte BGP AS Number";
                      }

                      leaf as-yy {
                        type uint32 {
                          range
                            "0..4294967295";
                        }
                        description
                          "2-byte or 4-byte BGP AS Number";
                      }

                      leaf index {
                        type uint32 {
                          range
                            "0..4294967295";
                        }
                        description
                          "AS Number Index";
                      }

                      leaf address {
                        type inet:ipv4-address-no-zone;
                        description
                          "IPv4 address";
                      }

                      leaf address-index {
                        type uint32 {
                          range "0..65535";
                        }
                        description
                          "IPv4 address index";
                      }
                    }  // container site-of-origin

                    container authentication {
                      description
                        "Authentication configuration";
                      leaf keychain {
                        type string;
                        description
                          "Authentication keychain configuration";
                      }
                    }  // container authentication

                    container summary-addresses {
                      description
                        "List of summary addresses under this interface";
                      list summary-address {
                        key "summary-address-addr summary-address-prefix";
                        description
                          "Summary address";
                        leaf summary-address-addr {
                          type inet:ip-address;
                          description
                            "Summary Prefix (address part)";
                        }

                        leaf summary-address-prefix {
                          type uint16 {
                            range "0..128";
                          }
                          description
                            "Summary Prefix (prefix part)";
                        }

                        leaf distance {
                          type uint32 {
                            range "1..255";
                          }
                          mandatory true;
                          description
                            "Administrative distance";
                        }
                      }  // list summary-address
                    }  // container summary-addresses

                    container interface-filter-policies {
                      description
                        "List of filter policies";
                      list interface-filter-policy {
                        key "direction";
                        description "none";
                        leaf direction {
                          type Eigrp-dir;
                          description
                            "Direction (in or out)";
                        }

                        leaf policy-name {
                          type string;
                          mandatory true;
                          description
                            "Policy name";
                        }
                      }  // list interface-filter-policy
                    }  // container interface-filter-policies

                    container interface-static-neighbors {
                      description
                        "List of Neighbors";
                      list interface-static-neighbor {
                        key "neighbor-address";
                        description
                          "Configure Neighbor";
                        leaf neighbor-address {
                          type inet:ip-address-no-zone;
                          description
                            "Neighbor IP address";
                        }

                        leaf max-hops {
                          type uint32 {
                            range "2..100";
                          }
                          mandatory true;
                          description
                            "Number of hops";
                        }
                      }  // list interface-static-neighbor
                    }  // container interface-static-neighbors

                    leaf hold-time {
                      type uint32 {
                        range "1..65535";
                      }
                      units "second";
                      description
                        "Neighbor hold time (in seconds)";
                    }

                    leaf bandwidth-percent {
                      type uint32 {
                        range "1..999999";
                      }
                      units "percentage";
                      description
                        "Bandwidth limit";
                    }

                    leaf passive-interface {
                      type boolean;
                      description
                        "Suppress routing updates on an interface";
                    }

                    leaf hello-interval {
                      type uint32 {
                        range "1..65535";
                      }
                      units "second";
                      description
                        "Interval (in seconds)";
                    }

                    leaf next-hop-self {
                      type empty;
                      description
                        "Disable next-hop-self";
                    }

                    leaf enable {
                      type empty;
                      description
                        "Enable Interface configuration";
                    }

                    leaf split-horizon {
                      type empty;
                      description
                        "Configure split horizon behaviour";
                    }

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

                container distance {
                  description
                    "Set distance for EIGRP routes";
                  leaf internal-distance {
                    type uint32 {
                      range "1..255";
                    }
                    description
                      "Internal routes' distance";
                  }

                  leaf external-distance {
                    type uint32 {
                      range "1..255";
                    }
                    description
                      "External routes' distance";
                  }
                }  // container distance

                leaf log-neighbor-changes {
                  type empty;
                  description
                    "Enable/Disable logginf of neighbor state changes";
                }
              }  // list default-af
            }  // container default-afs

            leaf enable {
              type empty;
              description
                "Enable EIGRP Default VRF
               configurationDeletion of this object also
               causes deletion of all objectsunder 'Process'
               associated with this process instance.";
            }
          }  // container default-vrf

          leaf nsf-disable {
            type empty;
            description
              "Disable NSF for all address families under all
             VRF's. It takes precedence over the NSF
             related configuration in the address family
             submode";
          }

          leaf process-id {
            type xr:Cisco-ios-xr-string {
              length "1..32";
            }
            description
              "AS number (1 - 65535) or Virutual instance
             name of the EIGRP process";
          }
        }  // list process
      }  // container processes
    }  // container eigrp
  }  // module Cisco-IOS-XR-eigrp-cfg