module Cisco-IOS-XE-wireless-rogue-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XE-wireless-rogue-oper";

    prefix wireless-rogue-oper;

    import Cisco-IOS-XE-event-history-types {
      prefix event-history-types;
    }
    import Cisco-IOS-XE-wireless-enum-types {
      prefix wireless-enum-types;
    }
    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 wireless rogue operational data.
     Copyright (c) 2016-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-07-01" {
      description
        "- Maximum-RSSI LRAD data for channel, encryption and WPA support.
       - Added statistics counter of dropped false-positive rogue reports.";
      reference
        "5.6.0";

    }

    revision "2021-03-01" {
      description
        "Removal of: parent-rogue-data-rogue-address-key, parent-rogue-client-data-rogue-client-address-key, parent-containment-lrad-key.";
      reference
        "5.5.0";

    }

    revision "2020-11-01" {
      description
        "- Added representation for Rogue Beacon DS Attack.
       - Added when statement to hide BSSID in containment parameters when containment does not involve clients or adhoc devices.
       - Deprecated Rogue RLDP operational model.";
      reference
        "5.4.0";

    }

    revision "2020-03-01" {
      description
        "- Added statistics for AP channel change events.
       - Added Protected Management Frames (PMF) flag.
       - Added statistics for Beacon DS attack events.
       - Added impersonation flag.
       - Added new statistics.";
      reference
        "5.3.0";

    }

    revision "2019-08-13" {
      description "- Added last heard SSID.";
      reference
        "5.2.0";

    }

    revision "2019-05-01" {
      description
        "- Added statistics for Rogue WSA events.
       - Renamed statistics for Rogue WSA events.
       - Added semantic version";
      reference
        "5.1.0";

    }

    revision "2019-01-10" {
      description
        "- Removal of unused leaves
       - Cleaned up spelling errors in descriptions.
       - Cleanup of the data model
       - Removed internal only leaves";
      reference
        "5.0.0";

    }

    revision "2018-08-16" {
      description
        "- Update rogue client IP address types.
       - Statistics for mobilityd interaction.
       - Reformat descriptions.";
      reference
        "4.0.0";

    }

    revision "2018-05-18" {
      description
        "Statistics for dropped updates for scale.";
      reference
        "3.1.0";

    }

    revision "2018-03-22" {
      description
        "Add support for Prime initiated Auto Containment.
       Move event grouping out from module";
      reference
        "3.0.0";

    }

    revision "2018-01-24" {
      description
        "The first generally available version";
      reference
        "2.0.0";

    }

    revision "2017-05-05" {
      description "Initial revision";
      reference
        "1.0.0";

    }

    cisco-semver:module-version "5.6.0";
    cisco-semver:module-version "5.5.0";
    cisco-semver:module-version "5.4.0";
    cisco-semver:module-version "5.3.0";
    cisco-semver:module-version "5.2.0";
    cisco-semver:module-version "5.1.0";
    cisco-semver:module-version "5.0.0";
    cisco-semver:module-version "4.0.0";
    cisco-semver:module-version "3.1.0";
    cisco-semver:module-version "3.0.0";
    cisco-semver:module-version "2.0.0";
    cisco-semver:module-version "1.0.0";

    typedef enm-rogue-class-type-change {
      type enumeration {
        enum "default-class-type" {
          value 0;
          description
            "Default Classification Type Change";
        }
        enum "manual-changed-class-type" {
          value 1;
          description
            "Manual Classification Type Change";
        }
        enum "auto-changed-class-type" {
          value 2;
          description
            "Automatic Classification Type Change";
        }
        enum "rogue-rule-changed-class-type" {
          value 3;
          description
            "Rule-based Classification Type Change";
        }
        enum "awips-changed-class-type" {
          value 4;
          description
            "AWIPS Classification Type Change";
        }
        enum "aaa-changed-class-type" {
          value 5;
          description
            "AAA Classification Type Change";
        }
      }
      description
        "Classification type change reason";
    }

    typedef enm-rogue-state-type-change {
      type enumeration {
        enum "default-state-type" {
          value 0;
          description
            "Default State Type Change";
        }
        enum "manual-changed-state-type" {
          value 1;
          description
            "Manual State Type Change";
        }
        enum "auto-changed-state-type" {
          value 2;
          description
            "Automatic State Type Change";
        }
        enum "rogue-rule-changed-state-type" {
          value 3;
          description
            "Rule-Based State Type Change";
        }
        enum "awips-changed-state-type" {
          value 4;
          description
            "AWIPS State Type Change";
        }
        enum "aaa-changed-state-type" {
          value 5;
          description
            "AAA State Type Change";
        }
      }
      description "State type change reason";
    }

    typedef enm-rogue-radio-type {
      type enumeration {
        enum "802-11-bg-radio-type" {
          value 1;
          description "802.11bg";
        }
        enum "802-11a-radio-type" {
          value 2;
          description "802.11a";
        }
        enum "802-11-abgn-radio-type" {
          value 3;
          description "802.11abgn";
        }
        enum "802-11ac-radio-type" {
          value 4;
          description "802.11ac";
        }
        enum "802-11-n-5g-radio-type" {
          value 5;
          description "802.11n 5 Ghz";
        }
        enum "802-11-n-24g-radio-type" {
          value 6;
          description "802.11n 2.4 Ghz";
        }
        enum "802-11g-radio-type" {
          value 7;
          description "802.11g";
        }
        enum "802-11ax-24g-radio-type" {
          value 8;
          description "802.11ax 2.4GHz";
        }
        enum "802-11ax-5g-radio-type" {
          value 9;
          description "802.11ax 5GHz";
        }
        enum "802-11ax-6g-radio-type" {
          value 10;
          description "802.11ax 6GHz";
        }
      }
      description "Radio Type";
    }

    typedef enm-rogue-containment-type {
      type enumeration {
        enum "invalid" {
          value 0;
          description
            "Invalid Containment Type";
        }
        enum "deauth-bcast" {
          value 1;
          description
            "Deauthentication Broadcast Containment";
        }
        enum "cfp" {
          value 2;
          description "CFP Containment";
        }
        enum "client-deauth" {
          value 3;
          description
            "Client Deauthentication Containment";
        }
        enum "adhoc-deauth" {
          value 4;
          description
            "AdHoc Deauthentication Containment";
        }
        enum "clear-all" {
          value 5;
          description
            "Clear all Existing Containment";
        }
      }
      description "Rogue Containment Type";
    }

    typedef enm-rogue-validation-result {
      type enumeration {
        enum "rogue-val-none" {
          value 0;
          description
            "Not Evaluated/Not Containing";
        }
        enum "rogue-contain-success" {
          value 1;
          description "Success.";
        }
        enum "skipped-not-monitor-ap" {
          value 2;
          description
            "Skipped: Not Monitor-AP.";
        }
        enum
          "failure-no-managed-ap-info-in-cache" {
          value 3;
          description
            "Failure: No Managed AP info in cache.";
        }
        enum "failure-no-radio-type-info" {
          value 4;
          description
            "Failure: No Radio Type info";
        }
        enum "failure-no-radio-oper-info" {
          value 5;
          description
            "Failure: No Radio Oper info";
        }
        enum "skipped-radio-is-down" {
          value 6;
          description
            "Skipped: Radio is Down";
        }
        enum "failure-no-country-string" {
          value 7;
          description
            "Failure: No Country String";
        }
        enum
          "skipped-invalid-channel-for-country" {
          value 8;
          description
            "Skipped: Invalid Channel for Country";
        }
        enum "failure-no-radar-mode-info" {
          value 9;
          description
            "Failure: No Radar mode info";
        }
        enum "skipped-dfs-channel" {
          value 10;
          description "Skipped: DFS Channel";
        }
        enum "failure-generic-db-error" {
          value 11;
          description
            "Failure: Generic DB Error";
        }
        enum
          "failure-error-sending-containment-message" {
          value 12;
          description
            "Failure: Error sending Containment message";
        }
        enum
          "skipped-max-scale-containment-reached-on" {
          value 13;
          description
            "Skipped: Max Scale Containment reached on AP";
        }
        enum
          "waiting-for-post-sso-cleanup-to-complete" {
          value 14;
          description
            "Waiting for post-SSO Cleanup to complete";
        }
        enum "failure-ap-in-wrong-mode" {
          value 15;
          description
            "Failure: AP in wrong mode";
        }
        enum "rogue-val-encr-enabled" {
          value 16;
          description
            "Encryption is enabled";
        }
        enum "rogue-val-ssid-too-long" {
          value 17;
          description "SSID is too long";
        }
        enum "rogue-val-hidden-ssid" {
          value 18;
          description "SSID is hidden";
        }
        enum "rogue-val-ap-in-use" {
          value 19;
          description "AP is in use";
        }
        enum "rogue-val-rldp-in-progress" {
          value 20;
          status deprecated;
          description "RLDP is in progress";
        }
        enum "rogue-val-mfp-required" {
          value 21;
          description
            "802.11w Protected Management Frames (PMF) is required";
        }
        enum "rogue-val-no-tx-radio-on-band" {
          value 22;
          description
            "The AP has not TX-enabled radio on this band";
        }
      }
      description "Validation result";
    }

    typedef enm-rogue-mfp {
      type enumeration {
        enum "rogue-mfp-required" {
          value 0;
          description
            "802.11w PMF is required";
        }
        enum "rogue-mfp-capable" {
          value 1;
          description
            "802.11w PMF capability exists, but it is not required";
        }
        enum "rogue-mfp-none" {
          value 2;
          description
            "802.11w PMF capability does not exist and is not required";
        }
      }
      description
        "Status of 802.11w Protected Management Frames (PMF)";
    }

    typedef enm-rogue-override-src {
      type enumeration {
        enum "rogue-override-none" {
          value 0;
          description
            "no override of classification or containment";
        }
        enum "rogue-override-config-ap" {
          value 1;
          description
            "override by rogue AP configuration";
        }
        enum "rogue-override-config-client" {
          value 2;
          description
            "override by rogue client configuration";
        }
        enum "rogue-override-snmp" {
          value 3;
          description
            "override by rogue AP SNMP setting";
        }
      }
      description
        "Classification and/or containment override reason";
    }

    typedef rogue-wpa-support-flag {
      type bits {
        bit wpa-support-wpa {
          position 0;
          description
            "WiFi Protected Access";
        }
        bit wpa-support-wpa2 {
          position 1;
          description
            "WiFi Protected Access 2";
        }
        bit wpa-support-ft {
          position 2;
          description "WiFi Fast Transition";
        }
        bit wpa-support-security-dot1x {
          position 3;
          description
            "802.1X authentication";
        }
        bit wpa-support-psk {
          position 4;
          description
            "WiFi WPA Pre-Shared Key";
        }
        bit wpa-support-security-owe {
          position 5;
          description
            "WiFi Protected Access 3 Opportunistic Wireless Encryption";
        }
        bit wpa-support-security-sae {
          position 6;
          description
            "WiFi Protected Access 3 Simultaneous Authentication of Equals";
        }
      }
      description
        "WPA and Security Support of the Rogue AP";
    }

    typedef rogue-encrypted-flag {
      type bits {
        bit rogue-encrypted-wep-mode {
          position 0;
          description
            "Rogue AP supports WiFi Wired Equivalent Privacy";
        }
      }
      description
        "Encrypted flag of Rogue AP report";
    }

    grouping st-rogue-ap-remote-override {
      description
        "Containment override manipulated remotely via a manageability interface";
      leaf remote-override-class-type {
        type wireless-enum-types:rogue-class-type;
        description
          "Remote Override Classification Type";
      }

      leaf remote-override-mode {
        type wireless-enum-types:rogue-state;
        description "Remote Override Mode";
      }

      leaf remote-override-containment-level {
        type uint32;
        description
          "Remote Override Containment level";
      }
    }  // grouping st-rogue-ap-remote-override

    grouping st-rogue-lrad-key {
      description "Local Radio Key";
      leaf lrad-mac-addr {
        type yang:mac-address;
        description
          "MAC Address of AP Interface that Detected the Rogue.";
      }

      leaf slot-id {
        type uint8;
        description
          "The slot ID of the AP Interface that detected the Rogue.";
      }
    }  // grouping st-rogue-lrad-key

    grouping st-rogue-data {
      description "Rogue AP data";
      leaf rogue-address {
        type yang:mac-address;
        description
          "MAC Address of a rogue AP.";
      }

      leaf rogue-class-type {
        type wireless-enum-types:rogue-class-type;
        description
          "This object specifies the type of a rogue AP.
         friendly     - existing known, acknowledged, and trusted APs
         malicious    - unknown AP that could be a threat.
         unclassified - an unknown or rogue AP is identified
           but it does not belong to Friendly or
           Malicious rogue types.
         custom       - AP that matches user defined custom rules.";
      }

      leaf rogue-mode {
        type wireless-enum-types:rogue-state;
        description
          "This objects specifies the state in which the rogue AP is.
         pending          - a read-only value indicates that rogue AP
         is under classification process
         alert            - rogue AP that can be a potential threat.
         Trap will be sent out to trap recipients.
         detectedLrad     - a read-only value indicates that a LRAD
         that got detected as rogue.
         known            - a read-only value indicates that an internal
         AP which is not on the same switch.
         acknowledge      - a read-only value indicates that an external
         AP whose existence is acceptable and not a
         threat (probably from vendor other than cisco).
         contained        - containment is initiated and ongoing.
         threat           - rogue AP is found on wired network.
         containedPending - a read-only value indicates that no AP
         resources are available for containment.
         knownContained   - a read-only value - no longer used.
         trustedMissing   - rogue AP is friendly but there is no slot
         for friendly AP.
         initializing     - a read-only value indicates that rogue
         AP is being initialized.
         For a friendly rogue AP, only two states are valid:
         'known' and 'acknowledge'.
         'known', 'knownContained' and 'trustedMissing'
         can appear in known rogue list.
         Known rogues can be pre-provisioned and known rogues
         state can be changed to 'alert'.";
      }

      leaf rogue-containment-level {
        type uint32;
        description "Containment Level";
      }

      leaf actual-containment {
        type uint32;
        description
          "Number of Containing APs.";
      }

      leaf manual-contained {
        type boolean;
        description "Manually Contained";
      }

      leaf class-override-src {
        type enm-rogue-override-src;
        description
          "Source of the classification/containment override";
      }

      leaf containment-type {
        type enm-rogue-containment-type;
        description
          "This object represents the containment mode applied to this rogue AP
         if it is in 'contained' state.
          A value of '0' indicates invalid containment mode.
          A value of '1' indicates deauthentication broadcast used for containment.
          A value of '2' indicates CFP containment.
          A value of '3' indicates client containment.
          A value of '4' indicates adhoc containment.
          A value of '5' indicates max value i.e invalid.
          A value of '99' indicates unknown containment type.";
      }

      leaf contained {
        type boolean;
        description "Contained";
      }

      leaf severity-score {
        type uint32;
        description
          "This object specifies the custom classification
         severity score of the rules.
         This object is applicable when cLRuleRogueType is configured as 'custom'.";
      }

      leaf class-type-custom-name {
        type string;
        description "custom rule";
      }

      leaf rogue-first-timestamp {
        type yang:date-and-time;
        description
          "Time Stamp when this Rogue was First Detected.";
      }

      leaf rogue-last-timestamp {
        type yang:date-and-time;
        description
          "Time Stamp when this Rogue was Last Detected.";
      }

      leaf rogue-is-on-my-network {
        type boolean;
        description
          "This attribute specifies if the Rogue is on Wired Network or not.";
      }

      leaf ad-hoc {
        type boolean;
        description
          "This attribute specifies if the Rogue is of ad-hoc type or is an AP.";
      }

      leaf ad-hoc-bssid {
        type yang:mac-address;
        description "BSSID for Ad-Hoc Rogue";
      }

      leaf rogue-rule-name {
        type string;
        description "Rule Name";
      }

      leaf rogue-radio-type-last-seen {
        type enm-rogue-radio-type;
        description "Last Seen Radio Type";
      }

      leaf rldp-retries {
        type uint32;
        status deprecated;
        description "RLDP attempts";
      }

      leaf rogue-class-type-change {
        type enm-rogue-class-type-change;
        description
          "Classification Type Change";
      }

      leaf rogue-state-change {
        type enm-rogue-state-type-change;
        description "State Type Change";
      }

      leaf rogue-if-num {
        type uint32;
        description "Interface Number";
      }

      leaf managed-ap {
        type boolean;
        description
          "There is a managed AP locally or via AP list with the same MAC";
      }

      leaf autocontain-adhoc-trap {
        type boolean;
        description
          "Trap for AdHoc Auto-Containment has been sent";
      }

      leaf autocontain-trap {
        type boolean;
        description
          "Trap for Auto-Containment has been sent";
      }

      leaf potential-honeypot-trap {
        type boolean;
        description
          "Trap for Potential Honeypot has been sent";
      }

      container history {
        description "Event History";
        uses event-history-types:event-history;
      }  // container history

      container rldp-history {
        status deprecated;
        description "RLDP Event History";
        uses event-history-types:event-history;
      }  // container rldp-history

      leaf rldp-last-result {
        type wireless-enum-types:rogue-rldp-result;
        status deprecated;
        description "RLDP Last Result";
      }

      leaf rldp-in-progress {
        type boolean;
        status deprecated;
        description "RLDP in progress";
      }

      leaf max-detected-rssi {
        type int8;
        description
          "This is the max RSSI value of all the detecting APs,
          which have detected this rogue.";
      }

      leaf ssid-max-rssi {
        type string;
        description
          "This is the SSID of the rogue detected by Access Point,
          which has max RSSI value of all the detecting APs of this rogue.";
      }

      leaf ap-name-max-rssi {
        type string;
        description
          "AP name of the detecting AP which received max RSSI";
      }

      leaf detecting-radio-type-802-11bg {
        type empty;
        description
          "Radio type of detecting APs. If the radio type is
         detected by dot11bg radio or dot11a radio or both.";
      }

      leaf detecting-radio-type-802-11a {
        type empty;
        description
          "Radio type of detecting APs. If the radio type is
         detected by dot11bg radio or dot11a radio or both.";
      }

      leaf detecting-radio-type-802-11abgn {
        type empty;
        description
          "Radio type of detecting APs. If the radio type is
         detected by dot11bg radio or dot11a radio or both.";
      }

      leaf detecting-radio-type-80211ac {
        type empty;
        description
          "Radio type of detecting APs. If the radio type is
         detected by dot11bg radio or dot11a radio or both.";
      }

      leaf detecting-radio-type-80211n-5g {
        type empty;
        description
          "Radio type of detecting APs. If the radio type is
         detected by dot11bg radio or dot11a radio or both.";
      }

      leaf detecting-radio-type-80211n-24g {
        type empty;
        description
          "Radio type of detecting APs. If the radio type is
         detected by dot11bg radio or dot11a radio or both.";
      }

      leaf detecting-radio-type-80211g {
        type empty;
        description
          "Radio type of detecting APs. If the radio type is
         detected by dot11bg radio or dot11a radio or both.";
      }

      leaf lrad-mac-max-rssi {
        type yang:mac-address;
        description
          "MAC Address of of detecting AP which received max RSSI";
      }

      leaf rogue-radio-type-max-rssi {
        type enm-rogue-radio-type;
        description
          "The radio type of detecting AP which received max  RSSI value.";
      }

      leaf last-channel {
        type uint32;
        description
          "This is the channel number of the last detecting APs,
         which has detected this rogue.";
      }

      leaf-list radio-type-count {
        type uint8;
        ordered-by user;
        description
          "Specifies the number of radio type count";
      }

      container last-heard-lrad-key {
        description "Last Local Radio Key";
        uses wireless-rogue-oper:st-rogue-lrad-key;
      }  // container last-heard-lrad-key

      leaf n-lrads {
        type uint32;
        description
          "Total number of APs that detected this rogue.";
      }

      list rogue-lrad {
        key "lrad-mac-addr slot-id";
        description
          "Local Radio that detected this rogue";
        uses wireless-rogue-oper:st-rogue-lrad;

        uses wireless-rogue-oper:st-rogue-lrad-key;
      }  // list rogue-lrad

      leaf n-clients {
        type uint32;
        description
          "Total number of Clients detected on this rogue.";
      }

      list rogue-client {
        key "rogue-client-address";
        description "Rogue Client Address";
        uses wireless-rogue-oper:st-rogue-client;
      }  // list rogue-client

      container remote-override {
        description
          "Remote containment override";
        uses wireless-rogue-oper:st-rogue-ap-remote-override;
      }  // container remote-override

      leaf last-heard-ssid {
        type string;
        description
          "Last detected SSID advertised by Rogue station.";
      }

      leaf mfp-required {
        type boolean;
        description
          "This rogue requires 802.11w PMF.";
      }

      leaf is-impersonation {
        type empty;
        description
          "This rogue in an impersonator.";
      }

      leaf beacon-ds-attack {
        type empty;
        description
          "This rogue performs Beacon DS DoS attack.";
      }

      leaf d-radio-type-802-11ax24g {
        type empty;
        description
          "Radio type of detecting APs. If the radio type is
         detected by 802.11ax 2.4GHz.";
      }

      leaf d-radio-type-802-11ax5g {
        type empty;
        description
          "Radio type of detecting APs. If the radio type is
         detected by 802.11ax 5GHz.";
      }

      leaf d-radio-type-802-11ax6g {
        type empty;
        description
          "Radio type of detecting APs. If the radio type is
         detected by 802.11ax 6GHz.";
      }

      leaf channel-max-rssi {
        type uint8;
        description
          "Channel reported by the maximum RSSI LRAD";
      }

      leaf wpa-support-max-rssi {
        type rogue-wpa-support-flag;
        description
          "WPA encryption reported by the maximum RSSI LRAD";
      }

      leaf encrypted-max-rssi {
        type rogue-encrypted-flag;
        description
          "Encryption reported by the maximum RSSI LRAD";
      }

      leaf snr-max-rssi {
        type int8;
        description
          "Signal-to-noise ratio of the maximum RSSI LRAD";
      }
    }  // grouping st-rogue-data

    grouping st-rogue-signal {
      description "Signal Level";
      leaf val {
        type int8;
        description "Value";
      }

      leaf num {
        type int16;
        description "Numerator";
      }

      leaf den {
        type int16;
        description "Denominator";
      }
    }  // grouping st-rogue-signal

    grouping st-rogue-lrad {
      description "Local Radio";
      leaf ssid {
        type string;
        description
          "This object represents the SSID Advertised by Rogue Station.";
      }

      leaf hidden-ssid {
        type boolean;
        description
          "This object represents the hidden ssid indication on this detecting AP.";
      }

      leaf name {
        type string;
        description
          "This object represents the name of
         Detecting AP Interface that detected the Rogue.";
      }

      container rssi {
        description
          "This object represents the Rogue RSSI as seen by Detecting AP Interface.";
        uses wireless-rogue-oper:st-rogue-signal;
      }  // container rssi

      container snr {
        description
          "This object represents the SNR seen by Detecting AP Interface from Rogue";
        uses wireless-rogue-oper:st-rogue-signal;
      }  // container snr

      leaf short-preamble {
        type uint8;
        description
          "This object represents the Preamble on this detecting AP.";
      }

      leaf channel {
        type uint32;
        description
          "This object represents the advertised Channel Number
         of the Detecting AP Interface picked up from the Rogue.";
      }

      leaf-list channels {
        type uint32;
        ordered-by user;
        description "Advertised channels";
      }

      leaf encrypted {
        type uint32;
        description
          "This object represents the encryption mode on this detecting AP.";
      }

      leaf wpa-support {
        type uint32;
        description
          "This object represents the WPA mode on this detecting AP.";
      }

      leaf dot11-phy-support {
        type uint32;
        description "Rogue Radio Type";
      }

      leaf last-heard {
        type yang:date-and-time;
        description
          "This object represents the no. of seconds ago when
         this Rogue was last heard by this AP.";
      }

      leaf chan-width {
        type uint16;
        description "Channel Width";
      }

      leaf chan-width-label {
        type uint16;
        description
          "This object represents the represents the channel width of the detecting AP.
         Each enumeration represents which part of the band the detecting AP is configured";
      }

      leaf ext-chan {
        type uint32;
        description "Extension Channel";
      }

      leaf band-id {
        type uint8;
        description "Band Identifier";
      }

      leaf num-slots {
        type uint32;
        description
          "Number of slots in this AP";
      }

      leaf report-radio-type {
        type uint32;
        description "Reported Radio Type";
      }

      leaf contain-result {
        type enm-rogue-validation-result;
        description
          "Last containment result";
      }

      leaf contain-slot-id {
        type wireless-enum-types:slot-id-type;
        description
          "Slot performing containment ";
      }

      leaf contain-radio-type {
        type uint32;
        description
          "Radio type for containment";
      }

      leaf radio-type {
        type enm-rogue-radio-type;
        description
          "This object represents the Detecting
         AP Interface type that detected the Rogue.";
      }

      leaf containment-type {
        type enm-rogue-containment-type;
        description
          "This object represents the containment mode used by the AP
         if the rogue is in 'contained' state.
          A value of '0' indicates invalid containment mode.
          A value of '1' indicates deauthentication broadcast used for containment.
          A value of '2' indicates CFP containment.
          A value of '3' indicates client containment.
          A value of '4' indicates adhoc containment.
          A value of '5' indicates max value i.e invalid.
          A value of '99' indicates unknown containment type.";
      }

      leaf containment-channel-count {
        type uint8;
        description
          "This object represents the number of channels used for rogue containment.";
      }

      leaf rogue-containment-chans {
        type string;
        description
          "This object represents the comma separated string
         of channels used for rogue containment.";
      }

      leaf auth-fail-count {
        type uint8;
        description
          "Authentication Failure Count";
      }

      leaf mfp-status {
        type enm-rogue-mfp;
        description
          "802.11w Protected Management Frames (PMF) status.";
      }

      leaf channel-from-ds {
        type boolean;
        description
          "Channel information is detected from DS Parameter Set.";
      }

      leaf phy-ap-slot {
        type uint8;
        description
          "Manageability AP slot of the reporting LRAD";
      }
    }  // grouping st-rogue-lrad

    grouping st-rogue-client {
      description
        "Rogue Client connected to a Rogue AP";
      leaf rogue-client-address {
        type yang:mac-address;
        description
          "MAC Address of the Rogue Client.";
      }
    }  // grouping st-rogue-client

    grouping st-rogue-client-data {
      description "Rogue Client";
      leaf rogue-client-address {
        type yang:mac-address;
        description
          "Mac Address of Rogue Station";
      }

      leaf rogue-client-bssid {
        type yang:mac-address;
        description "Rogue BSSID";
      }

      leaf rogue-client-gateway {
        type yang:mac-address;
        description
          "This object represents the MAC Address of the rogue AP Client gateway.";
      }

      leaf rogue-client-state {
        type wireless-enum-types:rogue-state;
        description
          "This attribute is use to specify the state in which
         the Rogue AP is. User can set the Rogue Client in
         alert,known or acknowledge state.
         Alert state means Rogue Client can be a potential
         threat. Trap will be sent out to trap recipients.
         Known state means its just internal Client which is
         not on the same Switch.
         Acknowledge state means an external Client whose
         existence is acceptable and not a threat
         (probably some other company's AP).
         Contained means containment is initiated and
         ongoing";
      }

      leaf rogue-client-containment-level {
        type uint32;
        description
          "If the state of the rogue is contained, this specifies
         the level of containment.  Higher the level, more the
         number of detecting APs that are used to contain it.
         The value must be between 1 to 4 for 'contained'
         state.";
      }

      leaf actual-containment {
        type uint32;
        description
          "Number of Containing APs";
      }

      leaf containment-type {
        type enm-rogue-containment-type;
        description
          "This object represents the containment mode applied to this rogue client
         if it is in 'contained' state.
          A value of '0' indicates invalid containment mode.
          A value of '1' indicates deauthentication broadcast used for containment.
          A value of '2' indicates CFP containment.
          A value of '3' indicates client containment.
          A value of '4' indicates adhoc containment.
          A value of '5' indicates max value i.e invalid.
          A value of '99' indicates unknown containment type.";
      }

      leaf rogue-client-if-num {
        type uint32;
        description
          "Rouge Client interface number";
      }

      leaf rogue-client-ipv4-addr {
        type inet:ipv4-address;
        description
          "Rogue Client IPv4 address.";
      }

      leaf rogue-client-ipv6-addr {
        type inet:ipv6-address;
        description
          "Rogue Client IPv6 address.";
      }

      leaf manual-contained {
        type boolean;
        description "Manually Contained";
      }

      leaf contained {
        type boolean;
        description "Contained";
      }

      leaf aaa-check {
        type boolean;
        description
          "AAA Validation Status of this rogue client";
      }

      leaf cmx-check {
        type boolean;
        description
          "CMX Validation Status of this rogue client";
      }

      leaf rogue-client-first-timestamp {
        type yang:date-and-time;
        description
          "Time Stamp when this Rogue was First Detected.";
      }

      leaf rogue-client-last-timestamp {
        type yang:date-and-time;
        description
          "Time Stamp when this Rogue was Last Detected.";
      }

      leaf n-lrads {
        type uint32;
        description
          "Total number of Airespace APs that detected this rogue.";
      }

      container last-heard-lrad-key {
        description "Last Local Radio Key";
        uses wireless-rogue-oper:st-rogue-lrad-key;
      }  // container last-heard-lrad-key

      container history {
        description
          "Event history for this rogue client";
        uses event-history-types:event-history;
      }  // container history

      leaf parent-rogue-data-address {
        type yang:mac-address;
        description
          "Mac Address of the rogue AP address this client is connected to";
      }

      list rogue-client-lrad {
        key "lrad-mac-addr slot-id";
        description
          "Local Radio that detected this rogue";
        uses wireless-rogue-oper:st-rogue-client-lrad;

        uses wireless-rogue-oper:st-rogue-lrad-key;
      }  // list rogue-client-lrad
    }  // grouping st-rogue-client-data

    grouping st-rogue-client-lrad {
      description
        "Local Radio that detected this rogue";
      leaf last-heard {
        type yang:date-and-time;
        description
          "No of seconds ago when this Rogue was last heard by this AP.";
      }

      leaf name {
        type string;
        description
          "Name of Airespace AP Interface that detected the Rogue.";
      }

      container rssi {
        description
          "RSSI seen by Airespace AP Interface from the Rogue";
        uses wireless-rogue-oper:st-rogue-signal;
      }  // container rssi

      container snr {
        description
          "SNR seen by Airespace AP Interface from Rogue";
        uses wireless-rogue-oper:st-rogue-signal;
      }  // container snr

      leaf channel {
        type uint32;
        description
          "The advertised Channel Number of that the
         Airespace AP Interface picked up from the Rogue.";
      }

      leaf band-id {
        type uint8;
        description "Band Identifier";
      }

      leaf num-slots {
        type uint32;
        description
          "Number of slots in this AP";
      }

      leaf contain-slot-id {
        type wireless-enum-types:slot-id-type;
        description
          "Slot performing containment ";
      }

      leaf contain-radio-type {
        type uint32;
        description
          "Radio type for containment";
      }

      leaf contain-result {
        type enm-rogue-validation-result;
        description
          "Last containment result.";
      }

      leaf phy-ap-slot {
        type uint8;
        description
          "Manageability AP slot of the reporting LRAD";
      }
    }  // grouping st-rogue-client-lrad

    grouping st-rogue-containment-params {
      description
        "Parameters of ongoing containments";
      leaf rogue-mac-address {
        type yang:mac-address;
        description
          "Mac Address of the Rogue";
      }

      leaf bssid {
        when
          "(../containment-type='client-deauth') or (../containment-type='adhoc-deauth')";
        type yang:mac-address;
        description "BSSID of the rogue";
      }

      leaf containment-type {
        type enm-rogue-containment-type;
        description "Containment Mode";
      }

      leaf-list chans {
        type uint8;
        ordered-by user;
        description "Containment Channels";
      }

      leaf detecting-slot-id {
        type wireless-enum-types:slot-id-type;
        description
          "The slot that detected the Rogue";
      }

      leaf band-id {
        type uint8;
        description
          "Band for this containment";
      }
    }  // grouping st-rogue-containment-params

    grouping st-rogue-containment-lrad {
      description
        "Local Radio performing containment";
      leaf n-contained {
        type uint32;
        description
          "Number of active containments on this Local Radio";
      }

      list params {
        key "rogue-mac-address";
        description "Containment Parameters";
        uses wireless-rogue-oper:st-rogue-containment-params;
      }  // list params
    }  // grouping st-rogue-containment-lrad

    grouping st-rogue-stats {
      description "Rogue Feature Statistics";
      leaf restart-count {
        type uint32;
        description
          "Number of process restarts";
      }

      leaf pending-count {
        type uint32;
        description
          "Number of rogue AP in pending state.";
      }

      leaf lrad-count {
        type uint32;
        description
          "Number of rogue AP in LRAD state.";
      }

      leaf on-my-network-count {
        type uint32;
        description
          "Number of rogue AP in my network.";
      }

      leaf adhoc-count {
        type uint32;
        description
          "Number of ad-hoc rogue APs.";
      }

      leaf unknown-count {
        type uint32;
        description
          "Number of unknown rogue APs.";
      }

      leaf unclassified-count {
        type uint32;
        description
          "Number of unclassified rogue APs.";
      }

      leaf malicious-count {
        type uint32;
        description
          "Number of malicious rogue APs.";
      }

      leaf friendly-count {
        type uint32;
        description
          "Number of friendly rogue APs.";
      }

      leaf custom-count {
        type uint32;
        description
          "Number of custom rogue APs.";
      }

      leaf not-adhoc-count {
        type uint32;
        description
          "Number of rogue APs (not adhoc)";
      }

      leaf total-count {
        type uint32;
        description
          "Number of rogue APs in total";
      }

      leaf contained-count {
        type uint32;
        description
          "Number of contained rogue APs";
      }

      leaf contained-client-count {
        type uint32;
        description
          "Number of contained rogue clients";
      }

      leaf contained-pending-count {
        type uint32;
        description
          "Number of containment-pending rogue APs";
      }

      leaf contained-pending-client-count {
        type uint32;
        description
          "Number of containment-pending rogue clients";
      }

      leaf total-client-count {
        type uint32;
        description
          "Number of rogue clients in total.";
      }

      leaf max-count {
        type uint32;
        description
          "Number of rogue APs that system can support.";
      }

      leaf max-client-count {
        type uint32;
        description
          "Number of rogue clients that system can support.";
      }

      leaf report-count {
        type uint64;
        description
          "Number of IAPP AP reports received.";
      }

      leaf client-report-count {
        type uint64;
        description
          "Number of IAPP Client reports received.";
      }

      leaf rate-report-count {
        type uint32;
        description
          "Number of IAPP AP reports received in last minute.";
      }

      leaf rate-client-report-count {
        type uint32;
        description
          "Number of IAPP Client reports received in last minute.";
      }

      leaf iapp-ap-pkt {
        type uint64;
        description
          "Number of IAPP AP packets received";
      }

      leaf iapp-client-pkt {
        type uint64;
        description
          "Number of IAPP Client packets received";
      }

      leaf rate-iapp-ap-pkt {
        type uint32;
        description
          "Number of IAPP AP packets received in last minute";
      }

      leaf rate-iapp-client-pkt {
        type uint32;
        description
          "Number of IAPP Client packets received in last minute";
      }

      leaf rldp-count {
        type uint64;
        status deprecated;
        description
          "Number of RLDP procedure started.";
      }

      leaf aaa-msg-rx-count {
        type uint64;
        description
          "Number of AAA messages received";
      }

      leaf aaa-msg-tx-count {
        type uint64;
        description
          "Number of AAA messages sent";
      }

      leaf snmp-traps-tx-count {
        type uint64;
        description
          "Number of SNMP traps sent";
      }

      leaf lrad-off-count {
        type uint64;
        description
          "Number of LRAD off events.";
      }

      leaf ap-create-count {
        type uint64;
        description
          "Number of AP create events.";
      }

      leaf ap-delete-count {
        type uint64;
        description
          "Number of AP delete events.";
      }

      leaf ap-radio-up-count {
        type uint64;
        description
          "Number of AP Radio Up events.";
      }

      leaf ap-radio-down-count {
        type uint64;
        description
          "Number of AP Radio Down events.";
      }

      leaf ap-name-change-count {
        type uint32;
        description
          "Number of AP Name Change events.";
      }

      leaf wncd-ipc-tx-count {
        type uint64;
        description
          "Number of IPCs to WNCDs sent.";
      }

      leaf wncd-ipc-rx-count {
        type uint64;
        description
          "Number of IPCs from WNCDs received.";
      }

      leaf wncmgr-ipc-rx-count {
        type uint64;
        description
          "Number of IPCs from WNCMGR received.";
      }

      leaf ios-ipc-tx-count {
        type uint64;
        description
          "Number of IPCs to IOS sent.";
      }

      leaf ios-ipc-rx-count {
        type uint64;
        description
          "Number of IPCs from IOS received.";
      }

      leaf nmspd-ipc-tx-count {
        type uint64;
        description
          "Number of IPCs to NMSPD sent.";
      }

      leaf nmspd-ipc-rx-count {
        type uint64;
        description
          "Number of IPCs from NMSPD received.";
      }

      leaf contain-msg-count {
        type uint64;
        description
          "Number of Containment msgs sent to APs.";
      }

      leaf fsm-errors {
        type uint32;
        description "Number of FSM errors";
      }

      leaf trap-errors {
        type uint32;
        description "Number of TRAP errors.";
      }

      container enq-count {
        description
          "Number of object enqueues.";
        uses event-history-types:dynamic-counter;
      }  // container enq-count

      leaf similar-ap-report-count {
        type uint64;
        description
          "Number of very-similar AP reports.";
      }

      leaf similar-client-report-count {
        type uint64;
        description
          "Number of very-similar client reports";
      }

      container snmp-traps-per-type {
        description "per-trap-type counter";
        uses event-history-types:dynamic-counter;
      }  // container snmp-traps-per-type

      leaf iapp-report-messages-load-shedded {
        type uint32;
        description
          "Number of IAPP report messages not processed due to rx IPC too-high occupancy.";
      }

      leaf managed-client-message-count {
        type uint32;
        description
          "Number of client join/leave messages.";
      }

      leaf managed-client-join-count {
        type uint32;
        description
          "number of client join events.";
      }

      leaf managed-client-leave-count {
        type uint32;
        description
          "Number of client leaving the run state events.";
      }

      leaf managed-rogue-client-count {
        type uint32;
        description
          "Number of managed clients matching rogue clients.";
      }

      container proc-time {
        description
          "per-processing-type average processing time";
        uses event-history-types:dynamic-counter;
      }  // container proc-time

      container global-history {
        description "Global Event History";
        uses event-history-types:event-history;
      }  // container global-history

      leaf tbl-apf-vap-cache-reload-count {
        type uint32;
        description
          "Count of APF VAP SSID cache reloads.";
      }

      leaf new-lrad-count {
        type uint64;
        description
          "Number of times a new LRAD has been added";
      }

      leaf lrad-purge-count {
        type uint64;
        description
          "Number of LRAD purge events";
      }

      leaf rssi-change-count {
        type uint64;
        description
          "Number of RSSI change events";
      }

      leaf final-state-change-count {
        type uint64;
        description
          "Number of times the final state has changed";
      }

      leaf contain-level-change-count {
        type uint64;
        description
          "Number of times the containment level has changed";
      }

      leaf class-change-count {
        type uint64;
        description
          "Number of Classification Type changes";
      }

      leaf adhoc-change-count {
        type uint64;
        description
          "Number of times adhoc status changed";
      }

      leaf on-my-network-change-count {
        type uint64;
        description
          "Number of times on-my-network status changed";
      }

      leaf n-clients-changed-count {
        type uint64;
        description
          "Number of times the client-number has changed";
      }

      leaf client-new-lrad-count {
        type uint64;
        description
          "Number of times a new client LRAD has been added";
      }

      leaf client-lrad-purge-count {
        type uint64;
        description
          "Number of client LRAD purge events";
      }

      leaf client-rssi-change-count {
        type uint64;
        description
          "Number of client RSSI change events";
      }

      leaf client-final-state-change-count {
        type uint64;
        description
          "Number of times the final client state has changed";
      }

      leaf client-contain-level-change-count {
        type uint64;
        description
          "Number of times the client containment level has changed";
      }

      leaf client-channel-change-count {
        type uint64;
        description
          "Number of channel change events";
      }

      leaf client-ip-change-count {
        type uint64;
        description
          "Number of IP-change events";
      }

      leaf client-roam-count {
        type uint64;
        description
          "Number of rogue-client-roam events";
      }

      leaf rogue-ap-reports-dropped-scale {
        type uint64;
        description
          "Number of rogue AP reports dropped due to max. scale reached";
      }

      leaf rogue-client-reports-dropped-scale {
        type uint64;
        description
          "Number of rogue client reports dropped due to max. scale reached";
      }

      leaf rogue-client-reports-dropped-no-parent {
        type uint64;
        description
          "Number of rogue client reports dropped due to missing parent rogue AP";
      }

      leaf rogue-enabled {
        type boolean;
        description
          "Rogue socket on port 5247 is enabled";
      }

      leaf mm-ipc-rx-count {
        type uint64;
        description
          "Number of IPCs from Mobilityd received.";
      }

      leaf rogue-wsa-events-triggered-counter {
        type uint64;
        description
          "Number of Rogue WSA events triggered";
      }

      leaf rogue-wsa-events-enqueued-counter {
        type uint64;
        description
          "Number of Rogue WSA events enqueued";
      }

      container rogue-wsa-events-triggered-per-type {
        description
          "Number of Rogue WSA events triggered per-type";
        uses event-history-types:dynamic-counter;
      }  // container rogue-wsa-events-triggered-per-type

      container rogue-wsa-events-enqueued-per-type {
        description
          "Number of Rogue WSA events enqueued per-type";
        uses event-history-types:dynamic-counter;
      }  // container rogue-wsa-events-enqueued-per-type

      leaf bssid-ipc-count {
        type uint64;
        description
          "Number of BSSID cache update events.";
      }

      leaf ap-channel-change-count {
        type uint64;
        description
          "Number of AP channel change events.";
      }

      leaf beacon-ds-attack-count {
        type uint64;
        description
          "Number of Beacon DS attacks detected.";
      }

      leaf internal-count {
        type uint32;
        description
          "Number of rogue APs in internal state.";
      }

      leaf external-count {
        type uint32;
        description
          "Number of rogue APs in external state.";
      }

      leaf alert-count {
        type uint32;
        description
          "Number of rogue APs in alert state.";
      }

      leaf threat-count {
        type uint32;
        description
          "Number of rogue APs in threat state.";
      }

      leaf rogue-ap-report-false-drop {
        type uint64;
        description
          "Number of rogue AP reports dropped because they might be falsely reported neighbor APs.";
      }
    }  // grouping st-rogue-stats

    grouping st-rldp-stats {
      description
        "Rogue Location Discovery Protocol feature statistics";
      leaf num-in-progress {
        type uint32;
        description
          "Total number of in-progress Rogue Location Discovery Protocol requests";
      }

      leaf num-rldp-started {
        type uint32;
        description
          "Total number of Rogue Location Discovery Protocol requests";
      }

      leaf auth-timeout {
        type uint32;
        description "Authentication timeout";
      }

      leaf assoc-timeout {
        type uint32;
        description "Association timeout";
      }

      leaf dhcp-timeout {
        type uint32;
        description "DHCP/ARP timeout";
      }

      leaf not-connected {
        type uint32;
        description "Not connected";
      }

      leaf connected {
        type uint32;
        description "Connected";
      }

      leaf rldp-socket-enabled {
        type boolean;
        description
          "Rogue Location Discovery Protocol socket on port 6352 is enabled";
      }
    }  // grouping st-rldp-stats

    grouping st-rldp-ap {
      description
        "Access Point that is performing RLDP";
      leaf ap-mac {
        type yang:mac-address;
        description
          "Manage AP mac address that is doing RLDP";
      }

      leaf slot-id {
        type wireless-enum-types:slot-id-type;
        description
          "Slot ID of the managed AP";
      }

      leaf rogue-ap-mac {
        type yang:mac-address;
        description
          "Rogue mac address against which RLDP is executed";
      }

      leaf rogue-channel {
        type uint32;
        description
          "Channel used to run RLDP";
      }

      leaf rogue-chan-width-label {
        type uint16;
        description
          "Rogue channel width label";
      }
    }  // grouping st-rldp-ap

    container rogue-oper-data {
      config false;
      description
        "Rogue Operational Data Model";
      container rogue-stats {
        presence "rogue-stats";
        description
          "Rogue Feature Statistics";
        uses wireless-rogue-oper:st-rogue-stats;
      }  // container rogue-stats

      list rogue-data {
        key "rogue-address";
        description "Rogue Access Point";
        uses wireless-rogue-oper:st-rogue-data;
      }  // list rogue-data

      list rogue-client-data {
        key "rogue-client-address";
        description "Rogue Client";
        uses wireless-rogue-oper:st-rogue-client-data;
      }  // list rogue-client-data

      list rogue-containment-lrad {
        key "lrad-mac-addr slot-id";
        description
          "Local Radio Performing Containment";
        uses wireless-rogue-oper:st-rogue-containment-lrad;

        uses wireless-rogue-oper:st-rogue-lrad-key;
      }  // list rogue-containment-lrad

      list rldp-ap {
        key "ap-mac";
        status deprecated;
        description "AP performing RLDP";
        uses wireless-rogue-oper:st-rldp-ap;
      }  // list rldp-ap

      container rldp-stats {
        presence "rldp-stats";
        status deprecated;
        description
          "RLDP Feature Statistics";
        uses wireless-rogue-oper:st-rldp-stats;
      }  // container rldp-stats
    }  // container rogue-oper-data
  }  // module Cisco-IOS-XE-wireless-rogue-oper