Cisco-IOS-XR-eigrp-oper

This module contains a collection of YANG definitions for Cisco IOS-XR eigrp package operational data. This module contains def...

  • Version: 2020-09-14

    Cisco-IOS-XR-eigrp-oper@2020-09-14


    
      module Cisco-IOS-XR-eigrp-oper {
    
        yang-version 1;
    
        namespace
          "http://cisco.com/ns/yang/Cisco-IOS-XR-eigrp-oper";
    
        prefix eigrp-oper;
    
        import Cisco-IOS-XR-types {
          prefix xr;
        }
        import cisco-semver {
          prefix semver;
        }
        import Cisco-IOS-XR-eigrp-datatypes {
          prefix dt1;
        }
    
        include Cisco-IOS-XR-eigrp-oper-sub1 {
          revision-date "2020-09-14";
        }
    
        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 operational data.
         
         This module contains definitions
         for the following management objects:
           eigrp: EIGRP operational data
         
         Copyright (c) 2013-2020 by Cisco Systems, Inc.
         All rights reserved.";
    
        revision "2020-09-14" {
          description
            "Changed Internal tag value to 32-bit.";
        }
    
        revision "2019-04-05" {
          description
            "Establish semantic version baseline.";
        }
    
        revision "2018-04-05" {
          description
            "Oper supported provided for oper data.";
        }
    
        revision "2015-11-09" {
          description "IOS XR 6.0 revision.";
        }
    
        semver:module-version "1.1.0";
        semver:module-version "1.0.1";
    
        container eigrp {
          config false;
          description "EIGRP operational data";
          container processes {
            description
              "Operational data for an EIGRP process";
            list process {
              key "process-id";
              description
                "Operational data for an EIGRP process";
              container vrfs-xr {
                description "List of VRFs";
                list vrf {
                  key "vrf-name";
                  description "A VRF";
                  leaf vrf-name {
                    type xr:Cisco-ios-xr-string;
                    description "VRF Name";
                  }
    
                  leaf vrf-name-xr {
                    type string;
                    description "VRF Name";
                  }
                }  // list vrf
              }  // container vrfs-xr
    
              container vrfs {
                description "List of VRFs";
                list vrf {
                  key "vrf-name";
                  description
                    "Operational data for a VRF";
                  container afs {
                    description
                      "List of Address Families";
                    list af {
                      key "af-name";
                      description
                        "Operational data for one AF";
                      container protocol {
                        description
                          "Address family specific protocol
                         information";
                        leaf afi {
                          type uint32;
                          description "AFI";
                        }
    
                        leaf as-number {
                          type uint32;
                          description
                            "AS Number";
                        }
    
                        leaf router-id {
                          type inet:ipv4-address;
                          description
                            "Router ID";
                        }
    
                        leaf auto-summarization {
                          type boolean;
                          description
                            "Auto Summarization";
                        }
    
                        leaf log-neighbor-changes {
                          type boolean;
                          description
                            "Neighbor changes logged";
                        }
    
                        leaf log-neighbor-warnings {
                          type boolean;
                          description
                            "Neighbor warnings logged";
                        }
    
                        leaf rib-table-limit-reached {
                          type boolean;
                          description
                            "RIB Table limit has been reached";
                        }
    
                        leaf outbound-filter-policy {
                          type string;
                          description
                            "Outbound Filter Policy";
                        }
    
                        leaf inbound-filter-policy {
                          type string;
                          description
                            "Inbound Filter Policy";
                        }
    
                        leaf outgoing-candidate-default-flagged {
                          type boolean;
                          description
                            "Default Allowed Out";
                        }
    
                        leaf outgoing-candidate-default-policy {
                          type string;
                          description
                            "Default Allowed Out Policy";
                        }
    
                        leaf incoming-candidate-default-flagged {
                          type boolean;
                          description
                            "Default Allowed In";
                        }
    
                        leaf incoming-candidate-default-policy {
                          type string;
                          description
                            "Default Allowed In Policy";
                        }
    
                        leaf internal-distance {
                          type uint8;
                          description
                            "Internal Distance";
                        }
    
                        leaf external-distance {
                          type uint8;
                          description
                            "External Distance";
                        }
    
                        leaf maximum-paths {
                          type uint8;
                          description
                            "Maximum paths";
                        }
    
                        leaf variance {
                          type uint8;
                          description "Variance";
                        }
    
                        leaf metric-weight-k1 {
                          type uint32;
                          description "K1 value";
                        }
    
                        leaf metric-weight-k2 {
                          type uint32;
                          description "K2 value";
                        }
    
                        leaf metric-weight-k3 {
                          type uint32;
                          description "K3 value";
                        }
    
                        leaf metric-weight-k4 {
                          type uint32;
                          description "K4 value";
                        }
    
                        leaf metric-weight-k5 {
                          type uint32;
                          description "K5 value";
                        }
    
                        leaf metric-weight-k6 {
                          type uint32;
                          description "K6 value";
                        }
    
                        leaf rib-scale {
                          type uint32;
                          description
                            "RIB Scale";
                        }
    
                        leaf metric-version {
                          type Eigrp-bd-metric-version;
                          description
                            "Metric Version";
                        }
    
                        leaf metric-maximum-hopcount {
                          type uint32;
                          description
                            "Metric MaxHops configured";
                        }
    
                        leaf default-metric-configured {
                          type boolean;
                          description
                            "Default Metric Configured";
                        }
    
                        leaf default-bandwidth {
                          type uint32;
                          description
                            "Default Bandwidth";
                        }
    
                        leaf default-delay {
                          type uint32;
                          description
                            "Default Delay";
                        }
    
                        leaf default-reliability {
                          type uint32;
                          description
                            "Default Reliability";
                        }
    
                        leaf default-load {
                          type uint32;
                          description
                            "Default Load";
                        }
    
                        leaf default-mtu {
                          type uint32;
                          description
                            "Default MTU";
                        }
    
                        leaf stub-configured {
                          type boolean;
                          description
                            "Stub Configured";
                        }
    
                        leaf stub-receive-only {
                          type boolean;
                          description
                            "Stub Receive-only configured";
                        }
    
                        leaf stub-allow-connected-routes {
                          type boolean;
                          description
                            "ConnectedRoutes allowed";
                        }
    
                        leaf stub-allow-static-routes {
                          type boolean;
                          description
                            "Static Routes allowed";
                        }
    
                        leaf stub-allow-summary-routes {
                          type boolean;
                          description
                            "Summary Routes allowed";
                        }
    
                        leaf stub-allow-redistributed-routes {
                          type boolean;
                          description
                            "Redistributed Routes allowed";
                        }
    
                        leaf nsf-enabled {
                          type boolean;
                          description
                            "NSF Enabled";
                        }
    
                        leaf nsf-route-hold-time {
                          type uint32;
                          description
                            "NSF Route Hold Time";
                        }
    
                        leaf nsf-signal-time {
                          type uint32;
                          description
                            "NSF Signal Time";
                        }
    
                        leaf nsf-converge-time {
                          type uint32;
                          description
                            "NSF Converge Time";
                        }
    
                        leaf restart-configured {
                          type boolean;
                          description
                            "Is Restart time configured";
                        }
    
                        leaf restart-time {
                          type uint32;
                          units "second";
                          description
                            "Restart time (seconds)";
                        }
    
                        leaf sia-active-time {
                          type uint32;
                          description
                            "SIA Active Time";
                        }
    
                        leaf rib-protocol-id {
                          type uint32;
                          description
                            "RIB Protocol ID";
                        }
    
                        leaf table-id {
                          type uint32;
                          description "Table ID";
                        }
    
                        leaf vrf-id {
                          type uint32;
                          description "VRF ID";
                        }
    
                        leaf ital-activation-received {
                          type boolean;
                          description
                            "VRF activated by ITAL";
                        }
    
                        leaf vrf-activated {
                          type boolean;
                          description
                            "VRF activated by EIGRP";
                        }
    
                        leaf up {
                          type boolean;
                          description
                            "VRF information available";
                        }
    
                        leaf rib-initialized {
                          type boolean;
                          description
                            "RIB initialization for VRF";
                        }
    
                        leaf rib-converged {
                          type boolean;
                          description
                            "RIB convergence for VRF";
                        }
    
                        leaf rib-converged-reload {
                          type boolean;
                          description
                            "Reload following RIB Convergence";
                        }
    
                        leaf socket-request {
                          type boolean;
                          description
                            "Requested Socket Option for VRF";
                        }
    
                        leaf socket-setup {
                          type boolean;
                          description
                            "Setup socket state for VRF";
                        }
    
                        leaf default-vrf {
                          type boolean;
                          description
                            "VRF represents default-context";
                        }
    
                        leaf af-enabled {
                          type boolean;
                          description
                            "AF Enabled";
                        }
    
                        leaf is-passive-default {
                          type boolean;
                          description
                            "Passive-Interface default configured";
                        }
    
                        leaf configured-items {
                          type uint32;
                          description
                            "VRF Configured Items";
                        }
    
                        leaf af-configured-items {
                          type uint32;
                          description
                            "AF Configured Items";
                        }
    
                        leaf ip-arm-router-id {
                          type uint32;
                          description
                            "IP ARM Router ID";
                        }
    
                        leaf first-interface-up-address {
                          type uint32;
                          description
                            "IP Address of first UP interface";
                        }
    
                        leaf nsf-in-progress {
                          type uint32;
                          description
                            "DDB NSF in progress indication";
                        }
    
                        leaf rib-table-converged {
                          type uint32;
                          description
                            "RIB Table convergence indication";
                        }
    
                        list redistributed-protocol {
                          description
                            "Redistributed Protocols";
                          leaf afi {
                            type uint32;
                            description "AFI";
                          }
    
                          leaf redistributed-protocol {
                            type string;
                            description
                              "Redistributed Protocol";
                          }
    
                          leaf redistributed-protocol-tag {
                            type string;
                            description
                              "Redistributed Protocol tag";
                          }
    
                          leaf redristribute-policy {
                            type string;
                            description
                              "Redistribute Filter policy";
                          }
    
                          leaf redistribute-protocol-id {
                            type uint32;
                            description
                              "Redistributed Protocol ID";
                          }
    
                          leaf rib-handle {
                            type uint32;
                            description
                              "Redistributed Protocol handle";
                          }
                        }  // list redistributed-protocol
    
                        list interface {
                          description
                            "Interfaces";
                          leaf afi {
                            type uint32;
                            description "AFI";
                          }
    
                          leaf interface {
                            type string;
                            description
                              "Interface";
                          }
    
                          leaf outbound-filter-policy {
                            type string;
                            description
                              "Outbound Filter Policy";
                          }
    
                          leaf inbound-filter-policy {
                            type string;
                            description
                              "Inbound Filter Policy";
                          }
    
                          leaf inactive {
                            type boolean;
                            description
                              "Interface is DOWN";
                          }
    
                          leaf passive-interface {
                            type boolean;
                            description
                              "Interface is passive";
                          }
                        }  // list interface
                      }  // container protocol
    
                      container ases {
                        description
                          "List of Autonomous Systems";
                        list as {
                          key "asn";
                          description
                            "Operational data for one AS";
                          container static-neighbors {
                            description
                              "EIGRP static neighbors";
                            list static-neighbor {
                              key "neighbor-address";
                              description
                                "Information on one static EIGRP
                               neighbor";
                              leaf neighbor-address {
                                type xr:Cisco-ios-xr-string;
                                description
                                  "Neighbor Address";
                              }
    
                              container source {
                                description
                                  "Neighbor address";
                                leaf ipv4-address {
                                  type inet:ipv4-address;
                                  description
                                    "IPv4 Address";
                                }
    
                                leaf ipv6-address {
                                  type inet:ipv6-address;
                                  description
                                    "IPv6 Address";
                                }
                              }  // container source
    
                              leaf afi {
                                type uint32;
                                description
                                  "AFI";
                              }
    
                              leaf as-number {
                                type uint32;
                                description
                                  "AS Number";
                              }
    
                              leaf interface-list {
                                type string;
                                description
                                  "Interface Name";
                              }
                            }  // list static-neighbor
                          }  // container static-neighbors
    
                          container topology-routes {
                            description
                              "EIGRP topology table";
                            list topology-route {
                              description
                                "Information about one EIGRP route";
                              leaf prefix {
                                type xr:Cisco-ios-xr-string;
                                description
                                  "IP Prefix";
                              }
    
                              leaf prefix-length {
                                type uint32 {
                                  range "0..128";
                                }
                                description
                                  "IP Prefix length";
                              }
    
                              container prefix-xr {
                                description
                                  "IP Prefix/length";
                                leaf ipv4-prefix {
                                  type inet:ipv4-address;
                                  description
                                    "IPv4 Prefix";
                                }
    
                                leaf ipv6-prefix {
                                  type inet:ipv6-address;
                                  description
                                    "IPv6 Prefix";
                                }
    
                                leaf prefix-length {
                                  type uint32;
                                  description
                                    "Prefix length";
                                }
                              }  // container prefix-xr
    
                              leaf afi {
                                type uint32;
                                description
                                  "AFI";
                              }
    
                              leaf as-number {
                                type uint32;
                                description
                                  "AS Number";
                              }
    
                              leaf router-id {
                                type inet:ipv4-address;
                                description
                                  "Router ID";
                              }
    
                              leaf active {
                                type boolean;
                                description
                                  "Active route";
                              }
    
                              leaf successors {
                                type uint32;
                                description
                                  "Successors";
                              }
    
                              leaf successors-present {
                                type boolean;
                                description
                                  "Are there successors";
                              }
    
                              leaf old-metric {
                                type uint32;
                                description
                                  "Deprecated. Please migrate to use OldMetric64.
    The value of this object might wrap since the
    metric value can go up to (2^48 - 1) in 64-bit
    metric mode";
                              }
    
                              leaf old-metric64 {
                                type uint64;
                                description
                                  "Old metric";
                              }
    
                              leaf metric {
                                type uint32;
                                description
                                  "Deprecated. Please migrate to use Metric64. The
    value of this object might wrap since the metric
    value can go up to (2^48 - 1) in 64-bit metric
    mode";
                              }
    
                              leaf metric64 {
                                type uint64;
                                description
                                  "Metric";
                              }
    
                              leaf rib-metric {
                                type uint32;
                                description
                                  "Metric downloaded to RIB";
                              }
    
                              leaf tag {
                                type uint32;
                                description
                                  "Tag";
                              }
    
                              leaf send-flag {
                                type Eigrp-bd-path-send-flag;
                                description
                                  "Send flag";
                              }
    
                              leaf transmit-serial-number {
                                type uint64;
                                description
                                  "Transmit thread Serial Number";
                              }
    
                              leaf transmit-refcount {
                                type uint32;
                                description
                                  "Transmit thread refcount";
                              }
    
                              leaf transmit-anchored {
                                type boolean;
                                description
                                  "Is Transmit thread anchored";
                              }
    
                              leaf reply-handles {
                                type uint32;
                                description
                                  "Reply handles used";
                              }
    
                              leaf active-time-secs {
                                type uint32;
                                units "second";
                                description
                                  "Active time seconds";
                              }
    
                              leaf active-time-nsecs {
                                type uint32;
                                units
                                  "nanosecond";
                                description
                                  "Active time nanoseconds";
                              }
    
                              leaf origin {
                                type uint32;
                                description
                                  "Origin";
                              }
    
                              leaf retry-count {
                                type uint32;
                                description
                                  "Retry count";
                              }
    
                              leaf active-stats {
                                type boolean;
                                description
                                  "Active stats flag";
                              }
    
                              leaf min-time {
                                type uint32;
                                description
                                  "Active stats min time";
                              }
    
                              leaf max-time {
                                type uint32;
                                description
                                  "Active stats max time";
                              }
    
                              leaf average-time {
                                type uint32;
                                description
                                  "Active stats average time";
                              }
    
                              leaf ack-count {
                                type uint32;
                                description
                                  "Active stats active count";
                              }
    
                              leaf replies {
                                type uint32;
                                description
                                  "Number of replies outstanding";
                              }
    
                              leaf route-in-sia {
                                type boolean;
                                description
                                  "Route is SIA";
                              }
    
                              leaf sia-reply-handles {
                                type uint32;
                                description
                                  "Reply handles used";
                              }
    
                              list paths {
                                description
                                  "Paths for this route";
                                container next-hop-address {
                                  description
                                    "Nexthop address";
                                  leaf ipv4-address {
                                    type inet:ipv4-address;
                                    description
                                      "IPv4 Address";
                                  }
    
                                  leaf ipv6-address {
                                    type inet:ipv6-address;
                                    description
                                      "IPv6 Address";
                                  }
                                }  // container next-hop-address
    
                                container infosource {
                                  description
                                    "Source of route";
                                  leaf ipv4-address {
                                    type inet:ipv4-address;
                                    description
                                      "IPv4 Address";
                                  }
    
                                  leaf ipv6-address {
                                    type inet:ipv6-address;
                                    description
                                      "IPv6 Address";
                                  }
                                }  // container infosource
    
                                leaf afi {
                                  type uint32;
                                  description
                                    "AFI";
                                }
    
                                leaf next-hop-present {
                                  type boolean;
                                  description
                                    "NH flag";
                                }
    
                                leaf interface-handle {
                                  type xr:Interface-name;
                                  description
                                    "Interface handle";
                                }
    
                                leaf interface-name {
                                  type string;
                                  description
                                    "Interface name";
                                }
    
                                leaf origin {
                                  type Eigrp-bd-path-origin;
                                  description
                                    "Origin of route";
                                }
    
                                leaf send-flag {
                                  type Eigrp-bd-path-send-flag;
                                  description
                                    "Send flag";
                                }
    
                                leaf reply-outstanding {
                                  type boolean;
                                  description
                                    "Outstanding reply";
                                }
    
                                leaf metric {
                                  type uint32;
                                  description
                                    "Deprecated. Please migrate to use Metric64. The
    value of this object might wrap since the metric
    value can go up to (2^48 - 1) in 64-bit metric
    mode";
                                }
    
                                leaf metric64 {
                                  type uint64;
                                  description
                                    "Metric";
                                }
    
                                leaf successor-metric {
                                  type uint32;
                                  description
                                    "Deprecated. Please migrate to use
    SuccessorMetric64. The value of this object
    might wrap since the metric value can go up to
    (2^48 - 1) in 64-bit metric mode";
                                }
    
                                leaf successor-metric64 {
                                  type uint64;
                                  description
                                    "Successor metric";
                                }
    
                                leaf reply-status {
                                  type boolean;
                                  description
                                    "Reply status";
                                }
    
                                leaf sia-status {
                                  type boolean;
                                  description
                                    "SIA status";
                                }
    
                                leaf transmit-serial-number {
                                  type uint64;
                                  description
                                    "Transmit thread serial number";
                                }
    
                                leaf anchored {
                                  type boolean;
                                  description
                                    "Is Transmit thread anchored";
                                }
    
                                leaf external-path {
                                  type boolean;
                                  description
                                    "External";
                                }
    
                                leaf bandwidth {
                                  type uint32;
                                  description
                                    "Deprecated. Please migrate to use Bandwidth64.";
                                }
    
                                leaf bandwidth64 {
                                  type uint64;
                                  description
                                    "Bandwidth";
                                }
    
                                leaf delay {
                                  type uint32;
                                  description
                                    "Deprecated. Please migrate to use Delay64. The
    value of this object might wrap if it is in
    picosecond units ";
                                }
    
                                leaf delay64 {
                                  type uint64;
                                  description
                                    "Delay";
                                }
    
                                leaf delay-unit {
                                  type Eigrp-bd-delay-unit;
                                  description
                                    "Delay units";
                                }
    
                                leaf mtu {
                                  type uint32;
                                  description
                                    "MTU";
                                }
    
                                leaf hop-count {
                                  type uint32;
                                  description
                                    "Hopcount";
                                }
    
                                leaf reliability {
                                  type uint8;
                                  description
                                    "Reliability";
                                }
    
                                leaf load {
                                  type uint8;
                                  description
                                    "Load";
                                }
    
                                leaf internal-router-id {
                                  type inet:ipv4-address;
                                  description
                                    "Router ID";
                                }
    
                                leaf internal-tag {
                                  type uint32;
                                  description
                                    "Internal Tag";
                                }
    
                                leaf extended-communities-present {
                                  type boolean;
                                  description
                                    "Extended communities present";
                                }
    
                                leaf extended-communities-length {
                                  type uint32;
                                  description
                                    "Length of extended communities";
                                }
    
                                leaf extended-communities {
                                  type yang:hex-string;
                                  description
                                    "Extended communities";
                                }
    
                                leaf external-information-present {
                                  type boolean;
                                  description
                                    "External information present";
                                }
    
                                leaf external-router-id {
                                  type uint32;
                                  description
                                    "Router ID";
                                }
    
                                leaf external-this-system {
                                  type boolean;
                                  description
                                    "Is it this system";
                                }
    
                                leaf external-as {
                                  type uint32;
                                  description
                                    "AS Number";
                                }
    
                                leaf external-protocol {
                                  type string;
                                  description
                                    "Protocol ID";
                                }
    
                                leaf external-metric {
                                  type uint32;
                                  description
                                    "Metric";
                                }
    
                                leaf external-tag {
                                  type uint32;
                                  description
                                    "Tag";
                                }
    
                                leaf conditional-default-path {
                                  type boolean;
                                  description
                                    "Conditional Default flag";
                                }
    
                                leaf rib-state {
                                  type Eigrp-bd-path-rib-state;
                                  description
                                    "State of path in RIB";
                                }
                              }  // list paths
    
                              list active-peer {
                                description
                                  "Peers yet to respond";
                                container source {
                                  description
                                    "Peer Address";
                                  leaf ipv4-address {
                                    type inet:ipv4-address;
                                    description
                                      "IPv4 Address";
                                  }
    
                                  leaf ipv6-address {
                                    type inet:ipv6-address;
                                    description
                                      "IPv6 Address";
                                  }
                                }  // container source
    
                                leaf peer-available {
                                  type boolean;
                                  description
                                    "Peer available";
                                }
    
                                leaf interface-list {
                                  type string;
                                  description
                                    "Interface name";
                                }
    
                                leaf handle-number {
                                  type uint32;
                                  description
                                    "Handle number";
                                }
                              }  // list active-peer
    
                              list sia-peer {
                                description
                                  "SIA Peers yet to respond";
                                container source {
                                  description
                                    "Peer Address";
                                  leaf ipv4-address {
                                    type inet:ipv4-address;
                                    description
                                      "IPv4 Address";
                                  }
    
                                  leaf ipv6-address {
                                    type inet:ipv6-address;
                                    description
                                      "IPv6 Address";
                                  }
                                }  // container source
    
                                leaf peer-available {
                                  type boolean;
                                  description
                                    "Peer available";
                                }
    
                                leaf interface-list {
                                  type string;
                                  description
                                    "Interface name";
                                }
    
                                leaf handle-number {
                                  type uint32;
                                  description
                                    "Handle number";
                                }
                              }  // list sia-peer
                            }  // list topology-route
                          }  // container topology-routes
    
                          container eigrp-accounting {
                            description
                              "Accounting info for one VRF AF";
                            leaf afi {
                              type uint32;
                              description "AFI";
                            }
    
                            leaf as-number {
                              type uint32;
                              description
                                "AS Number";
                            }
    
                            leaf router-id {
                              type inet:ipv4-address;
                              description
                                "Router ID";
                            }
    
                            leaf aggregate-count {
                              type uint32;
                              description
                                "Number of aggregates";
                            }
    
                            leaf state {
                              type int8;
                              description
                                "Redist state";
                            }
    
                            leaf redist-prefix-count {
                              type uint32;
                              description
                                "Redist prefix count";
                            }
    
                            leaf restart-count {
                              type uint32;
                              description
                                "Restart count";
                            }
    
                            leaf time-left {
                              type uint32;
                              description
                                "Time left";
                            }
    
                            leaf redist-prefix-present {
                              type boolean;
                              description
                                "Are there redist'ed prefixes ?";
                            }
    
                            list peer-statistics {
                              description
                                "Peers and their status";
                              container source {
                                description
                                  "Source address";
                                leaf ipv4-address {
                                  type inet:ipv4-address;
                                  description
                                    "IPv4 Address";
                                }
    
                                leaf ipv6-address {
                                  type inet:ipv6-address;
                                  description
                                    "IPv6 Address";
                                }
                              }  // container source
    
                              leaf afi {
                                type uint32;
                                description
                                  "AFI";
                              }
    
                              leaf state {
                                type int8;
                                description
                                  "State";
                              }
    
                              leaf interface-list {
                                type string;
                                description
                                  "Interface name";
                              }
    
                              leaf peer-prefix-count {
                                type uint32;
                                description
                                  "Peer prefix count";
                              }
    
                              leaf restart-count {
                                type uint32;
                                description
                                  "Restart count";
                              }
    
                              leaf time-left {
                                type uint32;
                                description
                                  "Time left";
                              }
                            }  // list peer-statistics
                          }  // container eigrp-accounting
    
                          container eigrp-traffic {
                            description
                              "Traffic info for one VRF AF";
                            leaf afi {
                              type uint32;
                              description "AFI";
                            }
    
                            leaf as-number {
                              type uint32;
                              description
                                "AS Number";
                            }
    
                            leaf hellos-sent {
                              type uint32;
                              description
                                "Hellos sent";
                            }
    
                            leaf hellos-received {
                              type uint32;
                              description
                                "Hellos received";
                            }
    
                            leaf updates-sent {
                              type uint32;
                              description
                                "Updates sent";
                            }
    
                            leaf updates-received {
                              type uint32;
                              description
                                "Updates received";
                            }
    
                            leaf queries-sent {
                              type uint32;
                              description
                                "Queries sent";
                            }
    
                            leaf queries-received {
                              type uint32;
                              description
                                "Queries received";
                            }
    
                            leaf replies-sent {
                              type uint32;
                              description
                                "Replies sent";
                            }
    
                            leaf replies-received {
                              type uint32;
                              description
                                "Replies received";
                            }
    
                            leaf acks-sent {
                              type uint32;
                              description
                                "Acks sent";
                            }
    
                            leaf acks-received {
                              type uint32;
                              description
                                "Acks received";
                            }
    
                            leaf sia-queries-sent {
                              type uint32;
                              description
                                "SIA Queries sent";
                            }
    
                            leaf sia-queries-received {
                              type uint32;
                              description
                                "SIA Queries received";
                            }
    
                            leaf sia-replies-sent {
                              type uint32;
                              description
                                "SIA Replies sent";
                            }
    
                            leaf sia-replies-received {
                              type uint32;
                              description
                                "SIA Replies received";
                            }
    
                            leaf max-queue-depth {
                              type uint32;
                              description
                                "Maximum queue depth";
                            }
    
                            leaf queue-drops {
                              type uint32;
                              description
                                "Queue drops";
                            }
                          }  // container eigrp-traffic
    
                          container eigrp-topology-summary {
                            description
                              "Topology summary info for one VRF AF";
                            leaf afi {
                              type uint32;
                              description "AFI";
                            }
    
                            leaf as-number {
                              type uint32;
                              description
                                "AS Number";
                            }
    
                            leaf router-id {
                              type inet:ipv4-address;
                              description
                                "Router ID";
                            }
    
                            leaf thread-present {
                              type boolean;
                              description
                                "Is thread present ?";
                            }
    
                            leaf transmit-serial-number {
                              type uint64;
                              description
                                "Thread serial number";
                            }
    
                            leaf next-serial-number {
                              type uint64;
                              description
                                "Next serial number";
                            }
    
                            leaf route-count {
                              type uint32;
                              description
                                "Number of routes";
                            }
    
                            leaf path-count {
                              type uint32;
                              description
                                "Number of paths";
                            }
    
                            leaf dummy-count {
                              type uint32;
                              description
                                "Dummy count";
                            }
    
                            leaf ddb-name {
                              type string;
                              description
                                "DDB Name";
                            }
    
                            leaf interface-count {
                              type uint32;
                              description
                                "Number of interfaces";
                            }
    
                            leaf handles-used {
                              type uint32;
                              description
                                "Number of handles used";
                            }
    
                            leaf active-interface-count {
                              type uint32;
                              description
                                "Number of active interfaces";
                            }
    
                            list quiescent {
                              description
                                "Quiescent interfaces";
                              leaf quiescent-interface-list {
                                type string;
                                description
                                  "Interface Name";
                              }
                            }  // list quiescent
                          }  // container eigrp-topology-summary
    
                          container interfaces {
                            description
                              "EIGRP interfaces";
                            list interface {
                              key "interface-name";
                              description
                                "Information for an EIGRP interface";
                              leaf interface-name {
                                type xr:Interface-name;
                                description
                                  "Interface Name";
                              }
    
                              leaf afi {
                                type uint32;
                                description
                                  "AFI";
                              }
    
                              leaf as-number {
                                type uint32;
                                description
                                  "AS Number";
                              }
    
                              leaf peer-count {
                                type uint32;
                                description
                                  "Peer Count";
                              }
    
                              leaf classic-peer-count {
                                type uint32;
                                description
                                  "Classic Peer Count";
                              }
    
                              leaf wide-peer-count {
                                type uint32;
                                description
                                  "Wide Peer Count";
                              }
    
                              leaf unreliable-transmits {
                                type uint32;
                                description
                                  "Unreliable transmissions";
                              }
    
                              leaf reliable-transmits {
                                type uint32;
                                description
                                  "Reliable transmissions";
                              }
    
                              leaf total-srtt {
                                type uint32;
                                description
                                  "Total SRTT";
                              }
    
                              leaf unreliable-send-interval {
                                type uint32;
                                description
                                  "Send interval for Unreliable transmissions";
                              }
    
                              leaf reliable-send-interval {
                                type uint32;
                                description
                                  "Send interval for Reliable transmissions";
                              }
    
                              leaf last-mc-flow-delay {
                                type uint32;
                                description
                                  "Last multicast flow delay";
                              }
    
                              leaf pending-routes {
                                type uint32;
                                description
                                  "Number of pending routes";
                              }
    
                              leaf hello-interval {
                                type uint32;
                                description
                                  "Hello interval";
                              }
    
                              leaf holdtime {
                                type uint32;
                                description
                                  "Hold time";
                              }
    
                              leaf bfd-enabled {
                                type boolean;
                                description
                                  "BFD enabled";
                              }
    
                              leaf bfd-interval {
                                type uint32;
                                description
                                  "BFD interval";
                              }
    
                              leaf bfd-multiplier {
                                type uint32;
                                description
                                  "BFD multiplier";
                              }
    
                              leaf serial-number-present {
                                type boolean;
                                description
                                  "Is serno present";
                              }
    
                              leaf transmit-serial-number {
                                type uint64;
                                description
                                  "Thread serial number";
                              }
    
                              leaf packetize-pending {
                                type boolean;
                                description
                                  "Packetize Timer pending";
                              }
    
                              leaf unreliable-multicast-sent {
                                type uint32;
                                description
                                  "Unreliable multicasts sent";
                              }
    
                              leaf reliable-multicast-sent {
                                type uint32;
                                description
                                  "Reliable multicasts sent";
                              }
    
                              leaf unreliable-unicast-sent {
                                type uint32;
                                description
                                  "Unreliable unicasts sent";
                              }
    
                              leaf reliable-unicast-sent {
                                type uint32;
                                description
                                  "Reliable unicasts sent";
                              }
    
                              leaf multicast-exceptions-sent {
                                type uint32;
                                description
                                  "Multicast Exceptions sent";
                              }
    
                              leaf cr-packets-sent {
                                type uint32;
                                description
                                  "CR packets sent";
                              }
    
                              leaf acks-suppressed {
                                type uint32;
                                description
                                  "Suppressed Acks";
                              }
    
                              leaf retransmissions-sent {
                                type uint32;
                                description
                                  "Retransmissions sent";
                              }
    
                              leaf out-of-sequence-received {
                                type uint32;
                                description
                                  "Out-of-sequence received";
                              }
    
                              leaf stub-interface {
                                type boolean;
                                description
                                  "All stub peers";
                              }
    
                              leaf next-hop-self-enabled {
                                type boolean;
                                description
                                  "Next-hop-self enabled";
                              }
    
                              leaf split-horizon-enabled {
                                type boolean;
                                description
                                  "SplitHorizon enabled";
                              }
    
                              leaf passive-interface {
                                type boolean;
                                description
                                  "Interface is passive";
                              }
    
                              leaf bandwidth-percent {
                                type uint32;
                                units
                                  "percentage";
                                description
                                  "Bandwidth percent";
                              }
    
                              leaf site-of-origin-type {
                                type Eigrp-bd-soo;
                                description
                                  "Site of Origin Type";
                              }
    
                              leaf site-of-origin {
                                type string;
                                description
                                  "Site of Origin";
                              }
    
                              leaf auth-mode {
                                type uint32;
                                description
                                  "Authentication Mode";
                              }
    
                              leaf auth-keychain {
                                type string;
                                description
                                  "Authentication Keychain Name";
                              }
    
                              leaf auth-key-exists {
                                type boolean;
                                description
                                  "Authentication key exists";
                              }
    
                              leaf auth-key-md5 {
                                type boolean;
                                description
                                  "Authentication key programmed with MD5 algorithm";
                              }
    
                              leaf auth-key-id {
                                type uint64;
                                description
                                  "Current active Authentication Key Id";
                              }
    
                              leaf total-pkt-recvd {
                                type uint32;
                                description
                                  "Total packets received";
                              }
    
                              leaf pkt-drop-wrong-kc {
                                type uint32;
                                description
                                  "Packets dropped due to wrong keychain configured";
                              }
    
                              leaf pkt-drop-no-auth {
                                type uint32;
                                description
                                  "Packets dropped due to missing authentication
    data";
                              }
    
                              leaf pkt-drop-invalid-auth {
                                type uint32;
                                description
                                  "Packets dropped due to invalid authentication
    data";
                              }
    
                              leaf pkt-accepted-valid-auth {
                                type uint32;
                                description
                                  "Packets accepted with valid authentication data";
                              }
    
                              leaf bandwidth {
                                type uint32;
                                description
                                  "Deprecated. Please migrate to use Bandwidth64.";
                              }
    
                              leaf bandwidth64 {
                                type uint64;
                                description
                                  "Bandwidth";
                              }
    
                              leaf delay {
                                type uint32;
                                description
                                  "Deprecated. Please migrate to use Delay64. The
    value of this object might wrap if it is in
    picosecond units";
                              }
    
                              leaf delay64 {
                                type uint64;
                                description
                                  "Delay";
                              }
    
                              leaf delay-unit {
                                type Eigrp-bd-delay-unit;
                                description
                                  "Delay unit";
                              }
    
                              leaf reliability {
                                type uint32;
                                description
                                  "Reliability";
                              }
    
                              leaf load {
                                type uint32;
                                description
                                  "Load";
                              }
    
                              leaf mtu {
                                type uint32;
                                description
                                  "MTU";
                              }
    
                              leaf configured-bandwidth {
                                type uint32;
                                description
                                  "Deprecated. Please migrate to use
    ConfiguredBandwidth64.";
                              }
    
                              leaf configured-bandwidth64 {
                                type uint64;
                                description
                                  "Configured bandwidth";
                              }
    
                              leaf configured-delay {
                                type uint32;
                                description
                                  "Deprecated. Please migrate to use
    ConfiguredDelay64. The value of this object
    might wrap if it is in picosecond units";
                              }
    
                              leaf configured-delay64 {
                                type uint64;
                                description
                                  "Configured delay";
                              }
    
                              leaf configured-delay-unit {
                                type Eigrp-bd-delay-unit;
                                description
                                  "Configured delay unit";
                              }
    
                              leaf configured-reliability {
                                type uint32;
                                description
                                  "Configured reliability";
                              }
    
                              leaf configured-load {
                                type uint32;
                                description
                                  "Configured load";
                              }
    
                              leaf configured-bandwidth-flag {
                                type boolean;
                                description
                                  "Bandwidth configured";
                              }
    
                              leaf configured-delay-flag {
                                type boolean;
                                description
                                  "Delay configured";
                              }
    
                              leaf configured-reliability-flag {
                                type boolean;
                                description
                                  "Reliability configured";
                              }
    
                              leaf configured-load-flag {
                                type boolean;
                                description
                                  "Load configured";
                              }
    
                              leaf up {
                                type boolean;
                                description
                                  "Interface is UP";
                              }
    
                              leaf type-supported {
                                type boolean;
                                description
                                  "Interface type is supported";
                              }
    
                              leaf ital-record-found {
                                type boolean;
                                description
                                  "ITAL Record valid";
                              }
    
                              leaf configured {
                                type boolean;
                                description
                                  "Interface config exists";
                              }
    
                              leaf multicast-enabled {
                                type boolean;
                                description
                                  "Requested socket state";
                              }
    
                              leaf socket-setup {
                                type boolean;
                                description
                                  "Setup socket state";
                              }
    
                              leaf lpts-socket-setup {
                                type boolean;
                                description
                                  "Setup LPTS socket state";
                              }
    
                              leaf primary-ipv4-address {
                                type inet:ipv4-address;
                                description
                                  "Primary IPv4 Address";
                              }
    
                              leaf ipv6-link-local-addr {
                                type inet:ipv6-address;
                                description
                                  "IPv6 LL Address";
                              }
    
                              leaf primary-prefix-length {
                                type uint32;
                                description
                                  "Primary prefix length";
                              }
    
                              leaf interface-handle {
                                type uint32;
                                description
                                  "Interface Handle";
                              }
    
                              leaf interface-type {
                                type uint32;
                                description
                                  "IM Interface Type";
                              }
    
                              leaf configured-items {
                                type uint32;
                                description
                                  "Interface Configured Items";
                              }
    
                              leaf is-passive-enabled {
                                type boolean;
                                description
                                  "Passive-Interface configured";
                              }
    
                              leaf is-passive-disabled {
                                type boolean;
                                description
                                  "Passive-Interface disabled";
                              }
    
                              list static-neighbor {
                                description
                                  "Static Neighbors";
                                leaf ipv4-address {
                                  type inet:ipv4-address;
                                  description
                                    "IPv4 Address";
                                }
    
                                leaf ipv6-address {
                                  type inet:ipv6-address;
                                  description
                                    "IPv6 Address";
                                }
                              }  // list static-neighbor
                            }  // list interface
                          }  // container interfaces
    
                          container eigrp-events {
                            description
                              "Events for a specific VRF AF";
                            leaf afi {
                              type uint32;
                              description "AFI";
                            }
    
                            leaf as-number {
                              type uint32;
                              description
                                "AS Number";
                            }
    
                            leaf current-event-index {
                              type uint32;
                              description
                                "Current event";
                            }
    
                            leaf eigrp-start-absolute-seconds {
                              type uint32;
                              units "second";
                              description
                                "Seconds since EIGRP started (absolute)";
                            }
    
                            leaf eigrp-start-absolute-nanoseconds {
                              type uint32;
                              units "second";
                              description
                                "Seconds since EIGRP started (absolute)";
                            }
    
                            leaf eigrp-start-relative-seconds {
                              type uint32;
                              units "second";
                              description
                                "Seconds since EIGRP started (relative)";
                            }
    
                            leaf eigrp-start-relative-nanoseconds {
                              type uint32;
                              units "second";
                              description
                                "Seconds since EIGRP started (relative)";
                            }
                          }  // container eigrp-events
    
                          container neighbors {
                            description
                              "EIGRP neighbors";
                            list neighbor {
                              key "neighbor-address";
                              description
                                "Information on one EIGRP neighbor";
                              leaf neighbor-address {
                                type xr:Cisco-ios-xr-string;
                                description
                                  "Neighbor Address";
                              }
    
                              container source {
                                description
                                  "Peer address";
                                leaf ipv4-address {
                                  type inet:ipv4-address;
                                  description
                                    "IPv4 Address";
                                }
    
                                leaf ipv6-address {
                                  type inet:ipv6-address;
                                  description
                                    "IPv6 Address";
                                }
                              }  // container source
    
                              leaf afi {
                                type uint32;
                                description
                                  "AFI";
                              }
    
                              leaf as-number {
                                type uint32;
                                description
                                  "AS Number";
                              }
    
                              leaf peer-suspended {
                                type boolean;
                                description
                                  "Is it a suspended peer";
                              }
    
                              leaf peer-handle {
                                type uint32;
                                description
                                  "Peer handle";
                              }
    
                              leaf interface-list {
                                type string;
                                description
                                  "Interface name";
                              }
    
                              leaf holdtime {
                                type uint32;
                                description
                                  "Hold time";
                              }
    
                              leaf uptime {
                                type uint32;
                                units "second";
                                description
                                  "UP time (seconds)";
                              }
    
                              leaf srtt {
                                type uint32;
                                description
                                  "Round trip time";
                              }
    
                              leaf rto {
                                type uint32;
                                description
                                  "RTO";
                              }
    
                              leaf bfd-enabled {
                                type boolean;
                                description
                                  "BFD enabled";
                              }
    
                              leaf queue-count {
                                type uint32;
                                description
                                  "Q counts";
                              }
    
                              leaf last-sequence-number {
                                type uint32;
                                description
                                  "Last sequence number";
                              }
    
                              leaf static-neighbor {
                                type boolean;
                                description
                                  "Is it a static neighbor";
                              }
    
                              leaf remote-neighbor {
                                type boolean;
                                description
                                  "Is it a remote ucast neighbor";
                              }
    
                              leaf hop-count {
                                type uint8;
                                description
                                  "Hop count of the static peer";
                              }
    
                              leaf restart-configured {
                                type boolean;
                                description
                                  "Is Restart time configured";
                              }
    
                              leaf restart-time {
                                type uint32;
                                units "second";
                                description
                                  "Restart time (seconds)";
                              }
    
                              leaf last-startup-serial-number {
                                type uint64;
                                description
                                  "Last startup serial number";
                              }
    
                              leaf ios-major-version {
                                type uint8;
                                description
                                  "IOS Major version";
                              }
    
                              leaf ios-minor-version {
                                type uint8;
                                description
                                  "IOS Minor version";
                              }
    
                              leaf eigrp-major-version {
                                type uint8;
                                description
                                  "EIGRP Major version";
                              }
    
                              leaf eigrp-minor-version {
                                type uint8;
                                description
                                  "EIGRP Major version";
                              }
    
                              leaf retransmission-count {
                                type uint32;
                                description
                                  "Retransmission count";
                              }
    
                              leaf retry-count {
                                type uint32;
                                description
                                  "Retry count";
                              }
    
                              leaf need-init {
                                type boolean;
                                description
                                  "Need EIGRP Init message";
                              }
    
                              leaf need-init-ack {
                                type boolean;
                                description
                                  "Need EIGRP InitAck message";
                              }
    
                              leaf reinitialization-needed {
                                type boolean;
                                description
                                  "Reinitialization needed";
                              }
    
                              leaf reinit-start {
                                type uint32;
                                description
                                  "Reinit period";
                              }
    
                              leaf peer-prefix-count {
                                type uint32;
                                description
                                  "Prefix count";
                              }
    
                              leaf stubbed {
                                type boolean;
                                description
                                  "Is it stubbed";
                              }
    
                              leaf allow-connected {
                                type boolean;
                                description
                                  "Connected routes accepted";
                              }
    
                              leaf allow-static {
                                type boolean;
                                description
                                  "Static routes accepted";
                              }
    
                              leaf allow-summaries {
                                type boolean;
                                description
                                  "Summary routes accepted";
                              }
    
                              leaf allow-redistributed {
                                type boolean;
                                description
                                  "Redist'ed routes accepted";
                              }
    
                              leaf test-handle {
                                type boolean;
                                description
                                  "Test handle flag";
                              }
    
                              leaf stubbed-interface {
                                type boolean;
                                description
                                  "Is it stubbed";
                              }
    
                              leaf suspended-reset {
                                type boolean;
                                description
                                  "Suspension manually reset";
                              }
    
                              leaf suspended-time-left {
                                type uint32;
                                description
                                  "Suspended time left";
                              }
    
                              list neighbor-queue {
                                description
                                  "Neighbor Queue";
                                leaf operation-code {
                                  type uint32;
                                  description
                                    "Operation Code";
                                }
    
                                leaf ack-sequnce-number {
                                  type uint32;
                                  description
                                    "ACK sequence number";
                                }
    
                                leaf start-serial-number {
                                  type uint64;
                                  description
                                    "Starting serial number";
                                }
    
                                leaf end-serial-number {
                                  type uint64;
                                  description
                                    "Ending serial number";
                                }
    
                                leaf pregenerated {
                                  type boolean;
                                  description
                                    "Pregenerated pak";
                                }
    
                                leaf packet-length {
                                  type uint32;
                                  description
                                    "pak len";
                                }
    
                                leaf time-sent-flag {
                                  type boolean;
                                  description
                                    "Has a pak been sent";
                                }
    
                                leaf time-sent {
                                  type uint32;
                                  description
                                    "Time sent";
                                }
    
                                leaf init-bit-set {
                                  type boolean;
                                  description
                                    "Is the init bit set";
                                }
    
                                leaf sequenced {
                                  type boolean;
                                  description
                                    "Is it sequenced";
                                }
                              }  // list neighbor-queue
                            }  // list neighbor
                          }  // container neighbors
    
                          container eigrp-statistics {
                            description
                              "Statistics for a specific VRF AF";
                            leaf afi {
                              type uint32;
                              description "AFI";
                            }
    
                            leaf as-number {
                              type uint32;
                              description
                                "AS Number";
                            }
    
                            leaf configured-interface-count {
                              type uint32;
                              description
                                "Configured interfaces";
                            }
    
                            leaf active-interfaces-count {
                              type uint32;
                              description
                                "Active interfaces";
                            }
    
                            leaf activate-count {
                              type uint64;
                              description
                                "Activate address family success count";
                            }
    
                            leaf activate-error {
                              type uint64;
                              description
                                "Activate address family failure count";
                            }
    
                            leaf activate-last-error {
                              type int32;
                              description
                                "Activate address family last error";
                            }
    
                            leaf deactivate-count {
                              type uint64;
                              description
                                "Deactivate address family success count";
                            }
    
                            leaf deactivate-error {
                              type uint64;
                              description
                                "Deactivate address family failure count";
                            }
    
                            leaf deactivate-last-error {
                              type int32;
                              description
                                "Deactivate address family last error";
                            }
    
                            leaf socket-set {
                              type uint64;
                              description
                                "Socket setup success count";
                            }
    
                            leaf socket-set-error {
                              type uint64;
                              description
                                "Socket setup failure count";
                            }
    
                            leaf sock-set-last-error {
                              type int32;
                              description
                                "Socket setup last error";
                            }
    
                            leaf raw-packet-in {
                              type uint64;
                              description
                                "Succeeded RAW packets in";
                            }
    
                            leaf raw-packet-in-error {
                              type uint64;
                              description
                                "Failed RAW packets ln";
                            }
    
                            leaf raw-packet-in-last-error {
                              type int32;
                              description
                                "RAW packets in last error";
                            }
    
                            leaf raw-packet-out {
                              type uint64;
                              description
                                "Succeeded RAW packets out";
                            }
    
                            leaf raw-packet-out-error {
                              type uint64;
                              description
                                "Failed RAW packets out";
                            }
    
                            leaf raw-packet-out-last-error {
                              type int32;
                              description
                                "RAW Packets out last error";
                            }
                          }  // container eigrp-statistics
    
                          leaf asn {
                            type uint32 {
                              range "1..65535";
                            }
                            description
                              "AS number";
                          }
                        }  // list as
                      }  // container ases
    
                      leaf af-name {
                        type dt1:Eigrp-af;
                        description
                          "Address Family";
                      }
                    }  // list af
                  }  // container afs
    
                  leaf vrf-name {
                    type xr:Cisco-ios-xr-string;
                    description "VRF Name";
                  }
                }  // list vrf
              }  // container vrfs
    
              leaf process-id {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "AS number or Virtual instance name of the
                 EIGRP process";
              }
            }  // list process
          }  // container processes
        }  // container eigrp
      }  // module Cisco-IOS-XR-eigrp-oper
    

© 2023 YumaWorks, Inc. All rights reserved.