submodule Cisco-IOS-XR-eigrp-oper-sub1 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-eigrp-oper {
        prefix Cisco-IOS-XR-eigrp-oper;
    }

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

    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 submodule contains a collection of YANG definitions
     for Cisco IOS-XR eigrp package 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";

    typedef Eigrp-bd-soo {
      type enumeration {
        enum "none" {
          value 0;
          description "No SoO configured";
        }
        enum "as" {
          value 1;
          description "AS:nn format";
        }
        enum "ipv4-address" {
          value 2;
          description
            "IPV4Address:nn format";
        }
        enum "four-byte-as" {
          value 3;
          description "AS2.AS:nn format";
        }
      }
      description "EIGRP SoO types";
    }

    typedef Eigrp-bd-path-rib-state {
      type enumeration {
        enum "active-path" {
          value 0;
          description "Active path";
        }
        enum "backup-path" {
          value 1;
          description "Backup path";
        }
        enum "path-sent-to-rib" {
          value 2;
          description "Path sent to RIB";
        }
        enum "path-not-selected" {
          value 3;
          description
            "Path not selected for installation in RIB";
        }
        enum "error-state" {
          value 4;
          description "Path in error state";
        }
      }
      description "Eigrp bd path rib state";
    }

    typedef Eigrp-bd-delay-unit {
      type enumeration {
        enum "none" {
          value 0;
          description "No Delay configured";
        }
        enum "ten-microsecond" {
          value 1;
          description
            "Delay in 10's of Microseconds";
        }
        enum "picosecond" {
          value 2;
          description "Delay in Picoseconds";
        }
        enum "microsecond" {
          value 3;
          description
            "Delay in Microseconds";
        }
      }
      description "EIGRP delay unit";
    }

    typedef Eigrp-bd-path-origin {
      type enumeration {
        enum "connected" {
          value 0;
          description
            "connected destination";
        }
        enum "static-redistributed" {
          value 1;
          description
            "static redistribution";
        }
        enum "connected-redistributed" {
          value 2;
          description
            "connected redistribution";
        }
        enum "subscriber-redistributed" {
          value 3;
          description
            "subscriber redistribution";
        }
        enum "redistributed" {
          value 4;
          description
            "redistributed destination";
        }
        enum "vpnv4-sourced" {
          value 5;
          description "vpnv4 destination";
        }
        enum "vpnv6-sourced" {
          value 6;
          description "vpnv6 destination";
        }
        enum "summary" {
          value 7;
          description "summary destination";
        }
        enum "dummy" {
          value 8;
          description
            "bogus drdb used for sia transmission";
        }
        enum "eigrp-destination" {
          value 9;
          description "igrp2 destination";
        }
        enum "origin-count" {
          value 10;
          description "Number of org types";
        }
      }
      description "EIGRP path origin";
    }

    typedef Eigrp-bd-path-send-flag {
      type enumeration {
        enum "no-send-pending" {
          value 0;
          description
            "No packet send pending";
        }
        enum "multicast-update-pending" {
          value 1;
          description
            "Multicast update pending";
        }
        enum "multicast-query-pending" {
          value 2;
          description
            "Multicast query pending";
        }
        enum "reply-pending" {
          value 3;
          description "Reply pending";
        }
        enum "sia-query-pending" {
          value 4;
          description "SIA Query pending";
        }
        enum "sia-reply-pending" {
          value 5;
          description "SIA Reply pending";
        }
      }
      description "EIGRP path send flag";
    }

    typedef Eigrp-bd-metric-version {
      type enumeration {
        enum "metric-version32-bit" {
          value 0;
          description
            "Metric version is 32 bit";
        }
        enum "metric-version64-bit" {
          value 1;
          description
            "Metric version is 64 bit";
        }
      }
      description "EIGRP metric version";
    }

    grouping EIGRP-SHOW-AF-STATS-BD {
      description "EIGRP AF statistics";
      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";
      }
    }  // grouping EIGRP-SHOW-AF-STATS-BD

    grouping EIGRP-SHOW-NBR-Q-BD {
      description "EIGRP 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";
      }
    }  // grouping EIGRP-SHOW-NBR-Q-BD

    grouping EIGRP-SHOW-NEIGHBORS-BD {
      description "EIGRP neighbor";
      container source {
        description "Peer address";
        uses EIGRP-ADDR-BD;
      }  // 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";
        uses EIGRP-SHOW-NBR-Q-BD;
      }  // list neighbor-queue
    }  // grouping EIGRP-SHOW-NEIGHBORS-BD

    grouping EIGRP-SHOW-EVENTS-BD {
      description "EIGRP DUAL events";
      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)";
      }
    }  // grouping EIGRP-SHOW-EVENTS-BD

    grouping EIGRP-SHOW-INTERFACES-BD {
      description "An EIGRP interface";
      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";
        uses EIGRP-ADDR-BD;
      }  // list static-neighbor
    }  // grouping EIGRP-SHOW-INTERFACES-BD

    grouping EIGRP-SHOW-QUIESCENT-IF-BD {
      description
        "EIGRP Quiescent Interface";
      leaf quiescent-interface-list {
        type string;
        description "Interface Name";
      }
    }  // grouping EIGRP-SHOW-QUIESCENT-IF-BD

    grouping EIGRP-SHOW-TOP-SUMMARY-BD {
      description "EIGRP Topology summary";
      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";
        uses EIGRP-SHOW-QUIESCENT-IF-BD;
      }  // list quiescent
    }  // grouping EIGRP-SHOW-TOP-SUMMARY-BD

    grouping EIGRP-SHOW-TRAFFIC-BD {
      description "EIGRP Traffic Statistics";
      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";
      }
    }  // grouping EIGRP-SHOW-TRAFFIC-BD

    grouping EIGRP-PEER-STATS-BD {
      description
        "EIGRP peer prefix statistics";
      container source {
        description "Source address";
        uses EIGRP-ADDR-BD;
      }  // 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";
      }
    }  // grouping EIGRP-PEER-STATS-BD

    grouping EIGRP-SHOW-ACCOUNTING-BD {
      description "EIGRP Accounting";
      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";
        uses EIGRP-PEER-STATS-BD;
      }  // list peer-statistics
    }  // grouping EIGRP-SHOW-ACCOUNTING-BD

    grouping EIGRP-SHOW-ACT-BD {
      description
        "EIGRP route's active peer information";
      container source {
        description "Peer Address";
        uses EIGRP-ADDR-BD;
      }  // 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";
      }
    }  // grouping EIGRP-SHOW-ACT-BD

    grouping EIGRP-SHOW-PATH-BD {
      description "An EIGRP path";
      container next-hop-address {
        description "Nexthop address";
        uses EIGRP-ADDR-BD;
      }  // container next-hop-address

      container infosource {
        description "Source of route";
        uses EIGRP-ADDR-BD;
      }  // 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";
      }
    }  // grouping EIGRP-SHOW-PATH-BD

    grouping EIGRP-PREFIX-BD {
      description "EIGRP IP v4/v6 Prefix";
      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";
      }
    }  // grouping EIGRP-PREFIX-BD

    grouping EIGRP-SHOW-ROUTE-BD {
      description "EIGRP Route";
      container prefix-xr {
        description "IP Prefix/length";
        uses EIGRP-PREFIX-BD;
      }  // 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";
        uses EIGRP-SHOW-PATH-BD;
      }  // list paths

      list active-peer {
        description "Peers yet to respond";
        uses EIGRP-SHOW-ACT-BD;
      }  // list active-peer

      list sia-peer {
        description
          "SIA Peers yet to respond";
        uses EIGRP-SHOW-ACT-BD;
      }  // list sia-peer
    }  // grouping EIGRP-SHOW-ROUTE-BD

    grouping EIGRP-ADDR-BD {
      description "EIGRP IP v4/v6 Address";
      leaf ipv4-address {
        type inet:ipv4-address;
        description "IPv4 Address";
      }

      leaf ipv6-address {
        type inet:ipv6-address;
        description "IPv6 Address";
      }
    }  // grouping EIGRP-ADDR-BD

    grouping EIGRP-SHOW-STATIC-NEIGHBORS-BD {
      description "EIGRP Static neighbor";
      container source {
        description "Neighbor address";
        uses EIGRP-ADDR-BD;
      }  // container source

      leaf afi {
        type uint32;
        description "AFI";
      }

      leaf as-number {
        type uint32;
        description "AS Number";
      }

      leaf interface-list {
        type string;
        description "Interface Name";
      }
    }  // grouping EIGRP-SHOW-STATIC-NEIGHBORS-BD

    grouping EIGRP-SHOW-PROT-INT-BD {
      description
        "EIGRP Protocol Interface information";
      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";
      }
    }  // grouping EIGRP-SHOW-PROT-INT-BD

    grouping EIGRP-SHOW-REDIST-BD {
      description
        "EIGRP Redist Protocol information";
      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";
      }
    }  // grouping EIGRP-SHOW-REDIST-BD

    grouping EIGRP-SHOW-PROT-VRF-BD {
      description
        "EIGRP VRF 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";
        uses EIGRP-SHOW-REDIST-BD;
      }  // list redistributed-protocol

      list interface {
        description "Interfaces";
        uses EIGRP-SHOW-PROT-INT-BD;
      }  // list interface
    }  // grouping EIGRP-SHOW-PROT-VRF-BD

    grouping EIGRP-VRFS-BD {
      description "EIGRP VRF Name";
      leaf vrf-name-xr {
        type string;
        description "VRF Name";
      }
    }  // grouping EIGRP-VRFS-BD
  }  // submodule Cisco-IOS-XR-eigrp-oper-sub1