submodule Cisco-IOS-XR-ethernet-link-oam-oper-sub1 {

    yang-version 1;

    belongs-to
      Cisco-IOS-XR-ethernet-link-oam-oper {
        prefix
          Cisco-IOS-XR-ethernet-link-oam-oper;
    }

    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 ethernet-link-oam package operational data.
     
     Copyright (c) 2013-2019 by Cisco Systems, Inc.
     All rights reserved.";

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

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

    semver:module-version "1.0.1";

    typedef Log-location {
      type enumeration {
        enum "log-location-local" {
          value 1;
          description "A local event";
        }
        enum "log-location-remote" {
          value 2;
          description "A remote event";
        }
      }
      description
        "The location of the event that caused a log entry";
    }

    typedef Log {
      type enumeration {
        enum "log-type-symbol-event" {
          value 1;
          description
            "Log entry for an errored symbol event";
        }
        enum "log-type-period-event" {
          value 2;
          description
            "Log entry for an errored frame period event";
        }
        enum "log-type-frame-event" {
          value 3;
          description
            "Log entry for an errored frame event";
        }
        enum "log-type-secs-event" {
          value 4;
          description
            "Log entry for an errored frame seconds summary
           event";
        }
        enum "log-type-link-fault" {
          value 256;
          description
            "Log entry for a link fault";
        }
        enum "log-type-dying-gasp" {
          value 257;
          description
            "Log entry for a dying gasp";
        }
        enum "log-type-critical-event" {
          value 258;
          description
            "Log entry for a critical event";
        }
      }
      description "The type of a log entry";
    }

    typedef Action {
      type enumeration {
        enum "no-action" {
          value 1;
          description
            "Disabled (do nothing)";
        }
        enum "disable-interface" {
          value 2;
          description
            "Disable the interface";
        }
        enum "log" {
          value 3;
          description
            "Log the event and do nothing else";
        }
        enum "efd" {
          value 4;
          description "EFD the interface";
        }
      }
      description
        "Actions supported by an OAM interface";
    }

    typedef Protocol-state {
      type enumeration {
        enum "protocol-state-inactive" {
          value 0;
          description
            "The protocol is in the INACTIVE state";
        }
        enum "protocol-state-fault" {
          value 1;
          description
            "The protocol is in the FAULT state";
        }
        enum
          "protocol-state-active-send-local" {
          value 2;
          description
            "The protocol is in the ACTIVE_SEND_LOCAL state";
        }
        enum "protocol-state-passive-wait" {
          value 3;
          description
            "The protocol is in the SEND_LOCAL_REMOTE state";
        }
        enum
          "protocol-state-send-local-remote" {
          value 4;
          description
            "The protocol is in the LOCAL_REMOTE state";
        }
        enum
          "protocol-state-send-local-remote-ok" {
          value 5;
          description
            "The protocol is in the LOCAL_REMOTE_OK state";
        }
        enum "protocol-state-send-any" {
          value 6;
          description
            "The protocol is in the SEND_ANY state";
        }
      }
      description
        "The state the protocol is in";
    }

    typedef Mode {
      type enumeration {
        enum "passive" {
          value 0;
          description "Passive mode";
        }
        enum "active" {
          value 1;
          description "Active mode";
        }
        enum "dont-care" {
          value 2;
          description
            "Don't care what the mode is";
        }
      }
      description "Mode of an OAM interface";
    }

    typedef Loopback-status {
      type enumeration {
        enum "none" {
          value 1;
          description
            "Loopback is not being performed";
        }
        enum "initiating" {
          value 2;
          description
            "Initiating master loopback";
        }
        enum "master-loopback" {
          value 3;
          description
            "In master loopback mode";
        }
        enum "terminating" {
          value 4;
          description
            "Terminating master loopback mode";
        }
        enum "local-loopback" {
          value 5;
          description
            "In slave loopback mode";
        }
        enum "unknown" {
          value 6;
          description
            "Parser and multiplexer combination unexpected";
        }
      }
      description
        "The loopback mode of an OAM interface";
    }

    typedef Operational-state {
      type enumeration {
        enum "disabled" {
          value 1;
          description
            "802.3 OAM is disabled";
        }
        enum "link-fault" {
          value 2;
          description
            "802.3 OAM has encountered a link fault";
        }
        enum "passive-wait" {
          value 3;
          description
            "Passive OAM entity waiting to see if peer is
           OAM capable";
        }
        enum "active-send-local" {
          value 4;
          description
            "Active OAM entity trying to determine if peer
           is OAM capable";
        }
        enum "send-local-and-remote" {
          value 5;
          description
            "OAM discovered peer but still to accept or
           reject peer config";
        }
        enum "send-local-and-remote-ok" {
          value 6;
          description
            "OAM peering is allowed by local device";
        }
        enum "peering-locally-rejected" {
          value 7;
          description
            "OAM peering rejected by local device";
        }
        enum "peering-remotely-rejected" {
          value 8;
          description
            "OAM peering rejected by remote device";
        }
        enum "operational" {
          value 9;
          description
            "802.3 OAM is operational";
        }
        enum "operational-half-duplex" {
          value 10;
          description
            "802.3 OAM is operating in half-duplex mode";
        }
      }
      description
        "Operational state of an interface";
    }

    grouping ELOD-STATS {
      description
        "Statistics for an 802.3 OAM interface";
      leaf information-tx {
        type uint32;
        description
          "Number of information OAMPDUs transmitted";
      }

      leaf information-rx {
        type uint32;
        description
          "Number of information OAMPDUs received";
      }

      leaf unique-event-notification-tx {
        type uint32;
        description
          "Number of unique event notification OAMPDUs
         transmitted";
      }

      leaf unique-event-notification-rx {
        type uint32;
        description
          "Number of unique event notification OAMPDUs
         received";
      }

      leaf duplicate-event-notification-tx {
        type uint32;
        description
          "Number of duplicate event notification OAMPDUs
         transmitted";
      }

      leaf duplicate-event-notification-rx {
        type uint32;
        description
          "Number of duplicate event notification OAMPDUs
         received";
      }

      leaf loopback-control-tx {
        type uint32;
        description
          "Number of loopback control OAMPDUs transmitted";
      }

      leaf loopback-control-rx {
        type uint32;
        description
          "Number of loopback control OAMPDUs received";
      }

      leaf variable-request-tx {
        type uint32;
        description
          "Number of variable request OAMPDUs transmitted";
      }

      leaf variable-request-rx {
        type uint32;
        description
          "Number of variable request OAMPDUs received";
      }

      leaf variable-response-tx {
        type uint32;
        description
          "Number of variable response OAMPDUs transmitted";
      }

      leaf variable-response-rx {
        type uint32;
        description
          "Number of variable response OAMPDUs received";
      }

      leaf org-specific-tx {
        type uint32;
        description
          "Number of organization specific OAMPDUs
         transmitted";
      }

      leaf org-specific-rx {
        type uint32;
        description
          "Number of organization specific OAMPDUs received";
      }

      leaf unsupported-codes-tx {
        type uint32;
        description
          "Number of OAMPDUs with unsupported codes
         transmitted";
      }

      leaf unsupported-codes-rx {
        type uint32;
        description
          "Number of OAMPDUs with unsupported codes
         received";
      }

      leaf frames-lost-due-to-oam {
        type uint32;
        description
          "Number of frames lost due to OAM";
      }

      leaf fixed-frames-rx {
        type uint32;
        description
          "Number of RX frames 'fixed' by OAM";
      }

      leaf local-error-symbol-period-records {
        type uint32;
        description
          "Number of local error symbol period records";
      }

      leaf local-error-frame-records {
        type uint32;
        description
          "Number of local error frame records";
      }

      leaf local-error-frame-period-records {
        type uint32;
        description
          "Number of local error frame period records";
      }

      leaf local-error-frame-second-records {
        type uint32;
        description
          "Number of local error frame second records";
      }

      leaf remote-error-symbol-period-records {
        type uint32;
        description
          "Number of remote error symbol period records";
      }

      leaf remote-error-frame-records {
        type uint32;
        description
          "Number of remote error frame records";
      }

      leaf remote-error-frame-period-records {
        type uint32;
        description
          "Number of remote error frame period records";
      }

      leaf remote-error-frame-second-records {
        type uint32;
        description
          "Number of remote error frame second records";
      }
    }  // grouping ELOD-STATS

    grouping ELOD-LOG-ENTRY {
      description "A single log entry";
      leaf index {
        type uint32;
        description
          "Index in the log entries table";
      }

      leaf handle {
        type xr:Interface-name;
        description
          "Interface handle for this log entry";
      }

      leaf oui {
        type yang:hex-string;
        description "OUI for the log entry";
      }

      leaf timestamp {
        type uint64;
        description
          "Timestamp in hundredths of a second since unix
         epoch for when the event occurred";
      }

      leaf type {
        type Log;
        description
          "Type of event that this entry describes";
      }

      leaf location {
        type Log-location;
        description
          "Where the event occurred";
      }

      leaf event-total {
        type uint32;
        description
          "Total number of times event has occurred";
      }

      leaf action-taken {
        type Action;
        description
          "Local action taken (If applicable)";
      }

      leaf window {
        type uint64;
        description
          "Size of the window (If applicable)";
      }

      leaf threshold {
        type uint64;
        description
          "Size of the threshold (If applicable)";
      }

      leaf local-high-threshold {
        type uint64;
        description
          "Size of the local high threshold (If applicable)
         . For remote threshold events this is scaled for
         comparison with the Breaching Value. This is to
         account for different local and remote window
         sizes.";
      }

      leaf value {
        type uint64;
        description
          "Breaching value (If applicable)";
      }

      leaf running-total {
        type uint64;
        description
          "The running total number of errors seen since
         OAM was enabled on the interface(If applicable)";
      }

      leaf window-config-units {
        type uint64;
        description
          "The window in the units that are currently
         configured";
      }

      leaf window-units {
        type uint8;
        description
          "The units in which the window size is configured
         .";
      }

      leaf threshold-config-units {
        type uint64;
        description
          "The threshold in the units that are currently
         configured";
      }

      leaf threshold-units {
        type uint8;
        description
          "The units in which the threshold size is
         configured.";
      }

      leaf local-high-threshold-config-units {
        type uint64;
        description
          "The local high threshold in the units that are
         currently configured";
      }

      leaf value-config-units {
        type uint64;
        description
          "The breaching value in the units that are
         currently configured";
      }
    }  // grouping ELOD-LOG-ENTRY

    grouping ELOD-SUMMARY-INFO {
      description
        "Summary information for all 802.3 OAM sessions on
       a node";
      leaf interfaces {
        type uint32;
        description
          "The number of interfaces with 802.3 OAM
         configured";
      }

      leaf port-down {
        type uint32;
        description
          "The number of interfaces in 'Port Down' state";
      }

      leaf passive-wait {
        type uint32;
        description
          "The number of interfaces in 'Passive Wait' state";
      }

      leaf active-send {
        type uint32;
        description
          "The number of interfaces in 'Active Send' state";
      }

      leaf evaluating {
        type uint32;
        description
          "The number of interfaces in 'Evaluating' state";
      }

      leaf local-accept {
        type uint32;
        description
          "The number of interfaces in 'Local Accept' state";
      }

      leaf local-reject {
        type uint32;
        description
          "The number of interfaces in 'Local Reject' state";
      }

      leaf remote-reject {
        type uint32;
        description
          "The number of interfaces in 'Remote Reject'
         state";
      }

      leaf operational {
        type uint32;
        description
          "The number of interfaces in 'Operational' state";
      }

      leaf loopback-mode {
        type uint32;
        description
          "The number of interfaces in loopback mode";
      }

      leaf miswired-connections {
        type uint32;
        description
          "The number of miswired connections";
      }

      leaf events {
        type uint64;
        description
          "The number of events recorded";
      }

      leaf local-events {
        type uint64;
        description
          "The number of local events recorded";
      }

      leaf local-symbol-period {
        type uint64;
        description
          "The number of local symbol period events
         recorded";
      }

      leaf local-frame {
        type uint64;
        description
          "The mumber of local frame error events recorded";
      }

      leaf local-frame-period {
        type uint64;
        description
          "The number of local frame period events recorded";
      }

      leaf local-frame-seconds {
        type uint64;
        description
          "The number of local frame second events recorded";
      }

      leaf remote-events {
        type uint64;
        description
          "The number of remote events recorded";
      }

      leaf remote-symbol-period {
        type uint64;
        description
          "The number of remote symbol period events
         recorded";
      }

      leaf remote-frame {
        type uint64;
        description
          "The mumber of remote frame error events recorded";
      }

      leaf remote-frame-period {
        type uint64;
        description
          "The number of remote frame period events
         recorded";
      }

      leaf remote-frame-seconds {
        type uint64;
        description
          "The number of remote frame second events
         recorded";
      }
    }  // grouping ELOD-SUMMARY-INFO

    grouping ELOD-RUNNING-CONFIG {
      description
        "The configuration currently running on an
       interface";
      leaf fast-hello-interval-enabled {
        type boolean;
        description
          "Is 100ms hello interval time enabled?";
      }

      leaf link-monitor-enabled {
        type boolean;
        description
          "Is link monitoring enabled?";
      }

      leaf remote-loopback-enabled {
        type boolean;
        description
          "Is remote loopback enabled?";
      }

      leaf mib-retrieval-enabled {
        type boolean;
        description
          "Is MIB retrieval enabled?";
      }

      leaf udlf-enabled {
        type boolean;
        description
          "Is uni-directional link-fault detection enabled?";
      }

      leaf mode {
        type Mode;
        description "Configured mode";
      }

      leaf connection-timeout {
        type uint8;
        description "Connection timeout";
      }

      leaf symbol-period-window {
        type uint32;
        description
          "Symbol period event window size";
      }

      leaf symbol-period-window-units {
        type uint8;
        description
          "Symbol period event window units";
      }

      leaf symbol-period-window-multiplier {
        type uint8;
        description
          "Symbol period event window multiplier";
      }

      leaf symbol-period-threshold-low {
        type uint64;
        description
          "Symbol period event low threshold";
      }

      leaf symbol-period-threshold-high {
        type uint64;
        description
          "Symbol period event high threshold";
      }

      leaf symbol-period-threshold-units {
        type uint8;
        description
          "Symbol period event threshold units";
      }

      leaf symbol-period-threshold-low-multiplier {
        type uint8;
        description
          "Symbol period event threshold low multiplier";
      }

      leaf symbol-period-threshold-high-multiplier {
        type uint8;
        description
          "Symbol period event threshold high multiplier";
      }

      leaf frame-window {
        type uint32;
        description
          "Frame event window size";
      }

      leaf frame-threshold-low {
        type uint64;
        description
          "Frame event low threshold";
      }

      leaf frame-threshold-high {
        type uint64;
        description
          "Frame event high threshold";
      }

      leaf frame-threshold-low-multiplier {
        type uint8;
        description
          "Frame period event threshold low multiplier";
      }

      leaf frame-threshold-high-multiplier {
        type uint8;
        description
          "Frame event threshold high multiplier";
      }

      leaf frame-period-window {
        type uint32;
        description
          "Frame period event window size";
      }

      leaf frame-period-window-units {
        type uint8;
        description
          "Frame period event window units";
      }

      leaf frame-period-window-multiplier {
        type uint8;
        description
          "Frame period event window multiplier";
      }

      leaf frame-period-threshold-low {
        type uint64;
        description
          "Frame period event low threshold";
      }

      leaf frame-period-threshold-high {
        type uint64;
        description
          "Frame period event high threshold";
      }

      leaf frame-period-threshold-units {
        type uint8;
        description
          "Frame period event threshold units";
      }

      leaf frame-period-threshold-low-multiplier {
        type uint8;
        description
          "Frame period event threshold low multiplier";
      }

      leaf frame-period-threshold-high-multiplier {
        type uint8;
        description
          "Frame period event threshold high multiplier";
      }

      leaf frame-seconds-window {
        type uint32;
        units "second";
        description
          "Frame seconds event high threshold";
      }

      leaf frame-seconds-threshold-low {
        type uint64;
        units "second";
        description
          "Frame seconds event high threshold";
      }

      leaf frame-seconds-threshold-high {
        type uint64;
        units "second";
        description
          "Frame seconds event high threshold";
      }

      leaf high-threshold-action {
        type Action;
        description
          "Action to perform when a high threshold is
         breached";
      }

      leaf link-fault-action {
        type Action;
        description
          "Action to perform when a link fault occurs";
      }

      leaf dying-gasp-action {
        type Action;
        description
          "Action to perform when a dying gasp occurs";
      }

      leaf critical-event-action {
        type Action;
        description
          "Action to perform when a critical event occurs";
      }

      leaf discovery-timeout-action {
        type Action;
        description
          "Action to perform when a discovery timeout
         occurs";
      }

      leaf capabilities-conflict-action {
        type Action;
        description
          "Action to perform when a capabilities conflict
         occurs";
      }

      leaf wiring-conflict-action {
        type Action;
        description
          "Action to perform when a wiring conflict occurs";
      }

      leaf session-up-action {
        type Action;
        description
          "Action to perform when a session comes up";
      }

      leaf session-down-action {
        type Action;
        description
          "Action to perform when a session comes down";
      }

      leaf remote-loopback-action {
        type Action;
        description
          "Action to perform when a session enters or exits
         remote loopback";
      }

      leaf require-remote-mode {
        type Mode;
        description
          "The mode that is required of the remote peer";
      }

      leaf require-remote-mib-retrieval {
        type boolean;
        description
          "Require the remote peer to support MIB retrieval";
      }

      leaf require-loopback {
        type boolean;
        description
          "Require the remote peer to support loopback mode";
      }

      leaf require-link-monitoring {
        type boolean;
        description
          "Require the remote peer to support link
         monitoring";
      }

      leaf fast-hello-interval-enabled-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf link-monitoring-enabled-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf remote-loopback-enabled-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf mib-retrieval-enabled-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf udlf-enabled-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf mode-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf connection-timeout-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf symbol-period-window-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf symbol-period-threshold-low-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf symbol-period-threshold-high-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf frame-window-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf frame-threshold-low-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf frame-threshold-high-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf frame-period-window-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf frame-period-threshold-low-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf frame-period-threshold-high-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf frame-seconds-window-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf frame-seconds-threshold-low-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf frame-seconds-threshold-high-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf high-threshold-action-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf link-fault-action-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf dying-gasp-action-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf critical-event-action-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf discovery-timeout-action-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf capabilities-conflict-action-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf wiring-conflict-action-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf session-down-action-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf session-up-action-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf remote-loopback-action-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf require-mode-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf require-mib-retrieval-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf require-loopback-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }

      leaf require-link-monitoring-overridden {
        type boolean;
        description
          "Is this configuration information an interface
         override?";
      }
    }  // grouping ELOD-RUNNING-CONFIG

    grouping EFD-TRIGGERS {
      description
        "Triggers currently causing the interface to be
       brought down using EFD";
      leaf link-fault-received {
        type boolean;
        description
          "Link-fault messages being received";
      }

      leaf discovery-timed-out {
        type boolean;
        description
          "The discovery process has timed out";
      }

      leaf capabilities-conflict {
        type boolean;
        description
          "A capabilities conflict has been detected";
      }

      leaf wiring-conflict {
        type boolean;
        description
          "A wiring conflict has been detected";
      }

      leaf session-down {
        type boolean;
        description
          "The 802.3 OAM session is down";
      }
    }  // grouping EFD-TRIGGERS

    grouping ELOD-ERRORS {
      description
        "Most recent error information for an 802.3 OAM
       interface";
      leaf pfi-reason {
        type string;
        description
          "Reason for the Interface Management error (if
         applicable)";
      }

      leaf pfi-error-code {
        type uint32;
        description
          "The Interface Management error/success code";
      }

      leaf platform-reason {
        type string;
        description
          "Reason for the platform error (if applicable)";
      }

      leaf platform-error-code {
        type uint32;
        description
          "The platform error/success code";
      }

      leaf spio-reason {
        type string;
        description
          "Reason for the Packet I/O error (if applicable)";
      }

      leaf spio-error-code {
        type uint32;
        description
          "The Packet I/O error/success code";
      }

      leaf epi-reason {
        type string;
        description
          "Reason for the Packet error (if applicable)";
      }

      leaf epi-error-code {
        type uint32;
        description
          "The Packet error/success code";
      }

      leaf caps-add-reason {
        type string;
        description
          "Reason for the caps add error (if applicable)";
      }

      leaf caps-add-error-code {
        type uint32;
        description
          "The caps add error/success code";
      }
    }  // grouping ELOD-ERRORS

    grouping ELOD-INTERFACE-STATE {
      description
        "The state of an 802.3 OAM interface";
      container errors {
        description
          "The errors that have occurred on this interface";
        uses ELOD-ERRORS;
      }  // container errors

      container efd-triggers {
        description
          "Any present EFD triggers";
        uses EFD-TRIGGERS;
      }  // container efd-triggers

      leaf protocol-code {
        type Protocol-state;
        description
          "The state the protocol is in";
      }

      leaf rx-fault {
        type boolean;
        description
          "Has a uni-directional link-fault been detected?";
      }

      leaf local-mwd-key {
        type uint32;
        description "The local MWD key";
      }

      leaf remote-mwd-key-present {
        type boolean;
        description
          "Does the remote side have an MWD key?";
      }

      leaf remote-mwd-key {
        type uint32;
        description "The remote MWD key";
      }
    }  // grouping ELOD-INTERFACE-STATE

    grouping ELOD-DISCOVERY-INFO {
      description
        "The results of a 'get discovery info' query";
      leaf name {
        type string;
        description "Interface Name";
      }

      leaf operational-status {
        type Operational-state;
        description "Operational status";
      }

      leaf loopback-mode {
        type Loopback-status;
        description
          "The loopback mode the interface is in";
      }

      leaf local-mode {
        type Mode;
        description
          "Local Mode (passive/active)";
      }

      leaf miswired {
        type boolean;
        description
          "Has the interface mis-wired?";
      }

      leaf local-mwd-key {
        type uint32;
        description
          "Local Mis-wiring Detection key";
      }

      leaf local-function-unidirectional {
        type boolean;
        description
          "Local Unidirectional support";
      }

      leaf local-function-loopback {
        type boolean;
        description "Local loopback support";
      }

      leaf local-function-event {
        type boolean;
        description "Local event support";
      }

      leaf local-functionvariable {
        type boolean;
        description
          "Local variable retreival support";
      }

      leaf local-revision {
        type uint32;
        description "Local revision";
      }

      leaf local-mtu {
        type uint32;
        description "Local MTU";
      }

      leaf local-operational {
        type boolean;
        description
          "Is the local OAM session operational?";
      }

      leaf local-evaluating {
        type boolean;
        description
          "Is the local OAM session evaluating?";
      }

      leaf remote-mode {
        type Mode;
        description
          "Remote Mode (passive/active)";
      }

      leaf remote-unidirectional {
        type boolean;
        description
          "Remote unidirectional support";
      }

      leaf remote-loopback {
        type boolean;
        description
          "Remote loopback support";
      }

      leaf remote-event {
        type boolean;
        description "Remote event support";
      }

      leaf remote-variable {
        type boolean;
        description
          "Remote variable retreival support";
      }

      leaf remote-mtu {
        type uint32;
        description "Remote MTU";
      }

      leaf remote-mac-address {
        type yang:mac-address;
        description "Remote MAC address";
      }

      leaf remote-vendor-oui {
        type yang:hex-string;
        description "Remote vendor OUI";
      }

      leaf remote-revision {
        type uint16;
        description "Remote revision";
      }

      leaf remote-vendor-info {
        type uint32;
        description "Remote vendor info";
      }

      leaf remote-mwd-key {
        type uint32;
        description
          "Remote Mis-wiring Detection key";
      }

      leaf operational-status-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf loopback-mode-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf local-mode-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf miswired-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf local-mwd-key-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf local-function-unidirectional-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf local-function-loopback-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf local-function-event-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf local-functionvariable-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf local-revisionvalid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf local-mtu-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf remote-mode-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf remote-unidirectional-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf remote-loopback-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf remote-event-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf remote-variable-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf remote-mtu-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf remote-mac-address-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf remote-vendor-oui-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf remote-revisionvalid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf remote-vendor-info-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf remote-mwd-key-valid {
        type boolean;
        description
          "Has this value been received successfully?";
      }

      leaf received-at-risk-notification-timestamp {
        type uint64;
        units "second";
        description
          "Timestamp of when the last At Risk notification
         was received (in seconds since the UNIX epoch),
         or 0 if the peer is not currently at risk";
      }

      leaf received-at-risk-notification-time-remaining {
        type uint16;
        units "second";
        description
          "Number of seconds remaining that the peer has
         indicated it will be At Risk";
      }
    }  // grouping ELOD-DISCOVERY-INFO
  }  // submodule Cisco-IOS-XR-ethernet-link-oam-oper-sub1