module Cisco-IOS-XE-stack-mgr-events-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XE-stack-mgr-events-oper";

    prefix stack-mgr-events-oper;

    import ietf-inet-types {
      prefix inet;
    }
    import ietf-yang-types {
      prefix yang;
    }
    import cisco-semver {
      prefix cisco-semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service

     Postal: 170 W Tasman Drive
     San Jose, CA 95134

     Tel: +1 1800 553-NETS

     E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG definitions
     for stack manager operations events generated from the Cisco Devices.
     These models may produce high volume of data.
     Copyright (c) 2019-2020 by Cisco Systems, Inc.
     All rights reserved";

    revision "2021-03-01" {
      description
        "- Add Dual-Active-Detection recovery and link timeout events for StackWise Virtual";
      reference
        "2.1.0";

    }

    revision "2020-07-01" {
      description
        "- Remove unused empty container stack-mgr-events";
      reference
        "2.0.0";

    }

    revision "2019-11-01" {
      description
        "- Added semantic version
       - Added version mismatch event";
      reference
        "1.1.0";

    }

    revision "2019-01-24" {
      description "Initial revision";
      reference
        "1.0.0";

    }

    cisco-semver:module-version "2.1.0";
    cisco-semver:module-version "2.0.0";
    cisco-semver:module-version "1.1.0";
    cisco-semver:module-version "1.0.0";

    typedef svl-protocol-status {
      type enumeration {
        enum "svl-conn-disconnected" {
          value 0;
          description
            "StackWise Virtual connection disconnected";
        }
        enum "svl-conn-pending" {
          value 1;
          description
            "StackWise Virtual connection pending";
        }
        enum "svl-conn-ready" {
          value 2;
          description
            "StackWise Virtual connection ready";
        }
        enum "svl-conn-error" {
          value 3;
          description
            "StackWise Virtual connection error";
        }
        enum "svl-conn-timeout" {
          value 4;
          description
            "StackWise Virtual connection timeout";
        }
      }
      description
        "StackWise Virtual port status";
    }

    typedef svl-port-status {
      type enumeration {
        enum "svl-port-down" {
          value 0;
          description
            "StackWise Virtual port down";
        }
        enum "svl-port-up" {
          value 1;
          description
            "StackWise Virtual port up";
        }
      }
      description
        "StackWise Virtual port status";
    }

    typedef svl-dad-sw-state {
      type enumeration {
        enum "svl-dad-recovery-mode" {
          value 0;
          description
            "Switch is entering recovery mode";
        }
        enum "svl-dad-active" {
          value 1;
          description "Switch is active";
        }
      }
      description
        "StackWise Virtual Dual-Active-Detection switch state";
    }

    typedef stacking-mode {
      type enumeration {
        enum "mode-stackwise-rear" {
          value 0;
          description "Mode Stackwise Rear";
        }
        enum "mode-active-standby" {
          value 1;
          description "Mode Active Standby";
        }
        enum "mode-stackwise-geo" {
          value 2;
          description "Mode Stackwise Geo";
        }
        enum "mode-stackwise-virtual" {
          value 3;
          description
            "Mode StackWise Virtual";
        }
        enum "mode-unknown" {
          value 4;
          description "Mode Unknown";
        }
      }
      description "Stack Mode";
    }

    typedef stack-mgr-notification-severity {
      type enumeration {
        enum "critical" {
          value 0;
        }
        enum "major" {
          value 1;
        }
        enum "minor" {
          value 2;
        }
      }
      description "Notification severity";
    }

    typedef stack-mgr-eventq-event-type {
      type enumeration {
        enum "node-added" {
          value 0;
          description
            "Node is added to the stack";
        }
        enum "node-removed" {
          value 1;
          description
            "Node is removed from the stack";
        }
        enum "node-new-master" {
          value 2;
          description
            "New Master or Active elected in the stack";
        }
        enum "node-version-mismatch" {
          value 3;
          description
            "Node version mismatch with other members in the stack";
        }
        enum "node-dual-active-recovery" {
          value 4;
          description
            "Dual-active detected and one switch went into recovery mode";
        }
        enum "node-svl-link-timeout" {
          value 5;
          description
            "StackWise Virtual link has timed out";
        }
      }
      description "Stack Node Role";
    }

    grouping svl-keepalive-stats {
      description
        "StackWise Virtual keepalive statistics";
      leaf lmp-tx {
        type uint64;
        description
          "Link-Management-Protocol TX counter";
      }

      leaf lmp-rx {
        type uint64;
        description
          "Link-Management-Protocol RX counter";
      }

      leaf lmp-tx-seq-no {
        type uint64;
        description
          "Last Link-Management-Protocol TX seq num";
      }

      leaf lmp-rx-seq-no {
        type uint64;
        description
          "Last Link-Management-Protocol RX seq num";
      }

      leaf lmp-rx-last-good-count {
        type uint64;
        description
          "Link-Management-Protocol RX last good count";
      }

      leaf latency-rx-err-count {
        type uint64;
        description
          "Latency RX error counts";
      }

      leaf seq-err-rx-count {
        type uint64;
        description
          "Sequence error RX counts";
      }

      leaf link-timeout-flap-count {
        type uint64;
        description
          "Link-Management-Protocol link timeout flap counts";
      }
    }  // grouping svl-keepalive-stats

    grouping svl-slot-port {
      description
        "StackWise Virtual port identification";
      leaf chassis {
        type uint32;
        description "Switch number";
      }

      leaf slot {
        type uint32;
        description "Switch slot";
      }

      leaf port {
        type uint32;
        description "Switch port";
      }
    }  // grouping svl-slot-port

    grouping svl-port-info {
      description
        "StackWise Virtual port information";
      container local-port {
        description "Local port info";
        uses stack-mgr-events-oper:svl-slot-port;
      }  // container local-port

      container remote-port {
        description "Remote port info";
        uses stack-mgr-events-oper:svl-slot-port;
      }  // container remote-port

      leaf port-status {
        type svl-port-status;
        description "Port status info";
      }

      leaf link-status-change-time {
        type yang:date-and-time;
        description
          "Link status change timestamp";
      }

      leaf link-protocol-status {
        type svl-protocol-status;
        description "Link protocol status";
      }

      leaf conn-status-change-time {
        type yang:date-and-time;
        description
          "Connection status change timestamp";
      }

      container port-stats {
        description "Local port statistics";
        uses stack-mgr-events-oper:svl-keepalive-stats;
      }  // container port-stats
    }  // grouping svl-port-info

    grouping dad-port-info {
      description
        "Dual-Active-Detection port information";
      container dad-port {
        description
          "Dual-Active-Detection port info";
        uses stack-mgr-events-oper:svl-slot-port;
      }  // container dad-port

      leaf port-status {
        type svl-port-status;
        description
          "Dual-Active-Detection port status info";
      }

      leaf tx-seq-no {
        type uint32;
        description
          "Dual-Active-Detection port next TX seq num";
      }
    }  // grouping dad-port-info

    grouping stack-node-keepalive {
      description "SDP keepalive counters";
      leaf sent {
        type uint64;
        description "Keepalives sent";
      }

      leaf received {
        type uint64;
        description "Keepalives received";
      }

      leaf sent-failure {
        type uint64;
        description
          "Keepalives failed to be sent";
      }

      leaf receive-failure {
        type uint64;
        description
          "Keepalives failed to be received";
      }

      leaf consecutive-losses {
        type uint64;
        description
          "Consecutive keepalives lost";
      }
    }  // grouping stack-node-keepalive

    grouping stack-ports-stats {
      description "Stack port stats";
      leaf rac-inserted {
        type uint64;
        units "bytes";
        description
          "Outgoing byte count on stack port";
      }

      leaf rac-copied {
        type uint64;
        units "bytes";
        description
          "Incoming byte count on stack port";
      }

      leaf rac-data-crc-err {
        type uint64;
        description
          "Stack interface data CRC error";
      }

      leaf rac-invalid-ringword-err {
        type uint64;
        description
          "Stack interface invalid ring word error";
      }

      leaf rac-pcs-codeword-err {
        type uint64;
        description
          "Stack interface PCS error";
      }

      leaf rac-rwcrc-err {
        type uint64;
        description
          "Stack interface ring word CRC error";
      }
    }  // grouping stack-ports-stats

    grouping stack-member-peer-timeout-info {
      description "Peer timeout Info";
      leaf peer-timeout-cfg {
        type uint64;
        units "milliseconds";
        description
          "Peer timeout in milliseconds";
      }

      leaf watermark-50-cnt {
        type uint64;
        description
          "Number of times keepalives missed for 50% of timeout value";
      }

      leaf watermark-75-cnt {
        type uint64;
        description
          "Number of times keepalives missed for 75% of timeout value";
      }

      leaf last-watermark-50time {
        when '(../watermark-50-cnt > 0)';
        type yang:date-and-time;
        description
          "Last time 50% watermark was exceeded";
      }

      leaf last-watermark-75time {
        when '(../watermark-75-cnt > 0)';
        type yang:date-and-time;
        description
          "Last time 75% watermark was exceeded";
      }
    }  // grouping stack-member-peer-timeout-info

    grouping stack-member-port-info {
      description "Stack member port data";
      leaf port-num {
        type uint8;
        description "Port number";
      }

      leaf cable-length-cm {
        when
          "(../../stack-mode!='mode-stackwise-virtual')";
        type uint16;
        units "centimeters";
        description
          "Stack cable length in centimetres";
      }

      leaf nbr-port-num {
        when
          "(../../stack-mode!='mode-stackwise-virtual')";
        type uint8;
        description "Neighbor port number";
      }

      leaf link-flaps {
        when
          "(../../stack-mode!='mode-stackwise-virtual')";
        type uint16;
        description "Number of link flaps";
      }

      container stats {
        when
          "(../../stack-mode!='mode-stackwise-virtual')";
        description "Stack port stats";
        uses stack-mgr-events-oper:stack-ports-stats;
      }  // container stats

      leaf stats-time {
        when
          "(../../stack-mode!='mode-stackwise-virtual')";
        type yang:date-and-time;
        description
          "Last time stats were collected";
      }

      list svl-port {
        when
          "(../../stack-mode='mode-stackwise-virtual')";
        description
          "StackWise Virtual ports statistics";
        uses stack-mgr-events-oper:svl-port-info;
      }  // list svl-port
    }  // grouping stack-member-port-info

    grouping stack-member-info {
      description "Stack member data";
      leaf chassis-num {
        type uint8;
        description "Switch number";
      }

      list mbr-port {
        description "Stack member port data";
        uses stack-mgr-events-oper:stack-member-port-info;
      }  // list mbr-port

      container mbr-keepalive {
        description
          "Stack member keepalive data";
        uses stack-mgr-events-oper:stack-node-keepalive;
      }  // container mbr-keepalive

      container mbr-peer-timeout {
        description
          "Stack member peer timeout data";
        uses stack-mgr-events-oper:stack-member-peer-timeout-info;
      }  // container mbr-peer-timeout

      leaf stack-mode {
        type stacking-mode;
        description "Stack mode";
      }

      list dad-port {
        when
          "(../stack-mode='mode-stackwise-virtual')";
        description
          "StackWise Virtual Dual-Active-Detection ports statistics";
        uses stack-mgr-events-oper:dad-port-info;
      }  // list dad-port

      leaf mbr-boottime {
        type yang:date-and-time;
        description "Stack member boot time";
      }
    }  // grouping stack-member-info

    grouping svl-dad-event-info {
      description
        "StackWise Virtual Dual-Active-Detection recovery event information";
      leaf switch-state {
        type svl-dad-sw-state;
        description "State of the switch";
      }

      container member-stats {
        description
          "Statistics of the switch during Dual-Active-Detection recovery event";
        uses stack-mgr-events-oper:stack-member-info;
      }  // container member-stats
    }  // grouping svl-dad-event-info

    grouping svl-timeout-event-info {
      description
        "StackWise Virtual link timeout event information";
      container local-port-info {
        description
          "Operational information of local port member";
        uses stack-mgr-events-oper:svl-port-info;
      }  // container local-port-info
    }  // grouping svl-timeout-event-info

    grouping stack-mgr-eventq-db-elem {
      description
        "Stack manager client events data model";
      leaf severity {
        type stack-mgr-notification-severity;
        description "Event severity";
      }

      leaf host-name {
        type string;
        description "Host name";
      }

      leaf system-ip {
        type inet:ip-address;
        description "Mgmt IP address";
      }

      leaf event {
        type stack-mgr-eventq-event-type;
        description
          "Stack Manager event type";
      }

      leaf member-number {
        type uint8;
        description
          "Stack member number for the event";
      }

      leaf serial-number {
        type string;
        description
          "Stack member serial number for the event";
      }

      leaf pid {
        type string;
        description
          "Stack member model number for the event";
      }

      choice event-detail-type-choice {
        description
          "Event type for additional details";
        container svl-dad-info {
          description
            "StackWise Virtual dual-active recovery event information";
          uses stack-mgr-events-oper:svl-dad-event-info;
        }  // container svl-dad-info
        container svl-link-timeout-info {
          description
            "StackWise Virtual link timeout event information";
          uses stack-mgr-events-oper:svl-timeout-event-info;
        }  // container svl-link-timeout-info
      }  // choice event-detail-type-choice
    }  // grouping stack-mgr-eventq-db-elem

    notification stkmevent {
      description
        "Stack manager client operational events. Provides an event for each significant activity in stack. It may generate high volume of data, depending on scale";
      uses stack-mgr-events-oper:stack-mgr-eventq-db-elem;
    }  // notification stkmevent
  }  // module Cisco-IOS-XE-stack-mgr-events-oper