// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// WARNING: THIS FILE IS MACHINE GENERATED. DO NOT EDIT.
// Generated from the fuchsia.wlan.fullmac banjo file

#![cfg_attr(rustfmt, rustfmt_skip)]
#![allow(unused_imports, non_camel_case_types)]

use fuchsia_zircon_types as zircon_types;
use banjo_fuchsia_wlan_common as fuchsia_wlan_common;
use fuchsia_wlan_common::*;
use banjo_fuchsia_wlan_ieee80211 as fuchsia_wlan_ieee80211;
use fuchsia_wlan_ieee80211::*;
use banjo_fuchsia_wlan_internal as fuchsia_wlan_internal;
use fuchsia_wlan_internal::*;

pub const WLAN_FULLMAC_MAX_HISTOGRAMS_PER_TYPE: u8 = 8;
pub const WLAN_FULLMAC_MAX_NOISE_FLOOR_SAMPLES: u8 = 255;
pub const WLAN_FULLMAC_MAX_RSSI_SAMPLES: u8 = 255;
pub const WLAN_FULLMAC_MAX_RX_RATE_INDEX_SAMPLES: u8 = 196;
pub const WLAN_FULLMAC_MAX_SNR_SAMPLES: u16 = 256;
pub const WLAN_FULLMAC_NUM_RATES_AC: u8 = 120;
pub const WLAN_FULLMAC_NUM_RATES_B: u8 = 4;
pub const WLAN_FULLMAC_NUM_RATES_G: u8 = 8;
pub const WLAN_FULLMAC_NUM_RATES_N: u8 = 64;
pub const WLAN_MAX_KEYLIST_SIZE: u32 = 4;
pub const WLAN_VIE_MAX_LEN: u32 = 514;
#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct DeleteKeyDescriptor {
    pub key_id: u16,
    pub key_type: WlanKeyType,
    pub address: [u8; 6 as usize],
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacAntennaId {
    pub freq: WlanFullmacAntennaFreq,
    pub index: u8,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacAssocInd {
    pub peer_sta_address: [u8; 6 as usize],
    pub listen_interval: u16,
    pub ssid: CSsid,
    pub rsne_len: u64,
    pub rsne: [u8; 257 as usize],
    pub vendor_ie_len: u64,
    pub vendor_ie: [u8; 514 as usize],
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacAuthInd {
    pub peer_sta_address: [u8; 6 as usize],
    pub auth_type: WlanAuthType,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacBandCapability {
    pub band: WlanBand,
    pub basic_rate_count: u8,
    pub basic_rate_list: [u8; 12 as usize],
    pub ht_supported: bool,
    pub ht_caps: HtCapabilities,
    pub vht_supported: bool,
    pub vht_caps: VhtCapabilities,
    pub operating_channel_count: u16,
    pub operating_channel_list: [u8; 256 as usize],
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacChannelSwitchInfo {
    pub new_channel: u8,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacConnectConfirm {
    pub peer_sta_address: [u8; 6 as usize],
    pub result_code: StatusCode,
    pub association_id: u16,
    pub association_ies_list: *const u8,
    pub association_ies_count: usize,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacDeauthIndication {
    pub peer_sta_address: [u8; 6 as usize],
    pub reason_code: ReasonCode,
    pub locally_initiated: bool,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacDelKeysReq {
    pub num_keys: u64,
    pub keylist: [DeleteKeyDescriptor; 4 as usize],
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacDisassocConfirm {
    pub status: zircon_types::zx_status_t,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacDisassocIndication {
    pub peer_sta_address: [u8; 6 as usize],
    pub reason_code: ReasonCode,
    pub locally_initiated: bool,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacEapolConfirm {
    pub result_code: WlanEapolResult,
    pub dst_addr: [u8; 6 as usize],
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacEapolIndication {
    pub src_addr: [u8; 6 as usize],
    pub dst_addr: [u8; 6 as usize],
    pub data_list: *const u8,
    pub data_count: usize,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacHistBucket {
    pub bucket_index: u16,
    pub num_samples: u64,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacIfaceCounterStats {
    pub rx_unicast_total: u64,
    pub rx_unicast_drop: u64,
    pub rx_multicast: u64,
    pub tx_total: u64,
    pub tx_drop: u64,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacNoiseFloorHistogram {
    pub hist_scope: WlanFullmacHistScope,
    pub antenna_id: WlanFullmacAntennaId,
    pub noise_floor_samples_list: *const WlanFullmacHistBucket,
    pub noise_floor_samples_count: usize,
    pub invalid_samples: u64,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacRssiHistogram {
    pub hist_scope: WlanFullmacHistScope,
    pub antenna_id: WlanFullmacAntennaId,
    pub rssi_samples_list: *const WlanFullmacHistBucket,
    pub rssi_samples_count: usize,
    pub invalid_samples: u64,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacRxRateIndexHistogram {
    pub hist_scope: WlanFullmacHistScope,
    pub antenna_id: WlanFullmacAntennaId,
    pub rx_rate_index_samples_list: *const WlanFullmacHistBucket,
    pub rx_rate_index_samples_count: usize,
    pub invalid_samples: u64,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacSnrHistogram {
    pub hist_scope: WlanFullmacHistScope,
    pub antenna_id: WlanFullmacAntennaId,
    pub snr_samples_list: *const WlanFullmacHistBucket,
    pub snr_samples_count: usize,
    pub invalid_samples: u64,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacQueryInfo {
    pub sta_addr: [u8; 6 as usize],
    pub role: WlanMacRole,
    pub band_cap_list: [WlanFullmacBandCapability; 16 as usize],
    pub band_cap_count: u8,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacSetKeysReq {
    pub num_keys: u64,
    pub keylist: [WlanKeyConfig; 4 as usize],
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacSetKeysResp {
    pub num_keys: u64,
    pub statuslist: [i32; 4 as usize],
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacSaeHandshakeResp {
    pub peer_sta_address: [u8; 6 as usize],
    pub status_code: StatusCode,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacSaeFrame {
    pub peer_sta_address: [u8; 6 as usize],
    pub status_code: StatusCode,
    pub seq_num: u16,
    pub sae_fields_list: *const u8,
    pub sae_fields_count: usize,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacScanResult {
    pub txn_id: u64,
    pub timestamp_nanos: zircon_types::zx_time_t,
    pub bss: BssDescription,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacScanEnd {
    pub txn_id: u64,
    pub code: WlanScanResult,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacRoamConfirm {
    pub target_bssid: [u8; 6 as usize],
    pub result_code: StatusCode,
    pub selected_bss: BssDescription,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacStartConfirm {
    pub result_code: WlanStartResult,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacStopConfirm {
    pub result_code: WlanStopResult,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacSignalReportIndication {
    pub rssi_dbm: i8,
    pub snr_db: i8,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacPmkInfo {
    pub pmk_list: *const u8,
    pub pmk_count: usize,
    pub pmkid_list: *const u8,
    pub pmkid_count: usize,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacSaeHandshakeInd {
    pub peer_sta_address: [u8; 6 as usize],
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacRssiStats {
    pub hist_list: *const u64,
    pub hist_count: usize,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacIfaceHistogramStats {
    pub noise_floor_histograms_list: *const WlanFullmacNoiseFloorHistogram,
    pub noise_floor_histograms_count: usize,
    pub rssi_histograms_list: *const WlanFullmacRssiHistogram,
    pub rssi_histograms_count: usize,
    pub rx_rate_index_histograms_list: *const WlanFullmacRxRateIndexHistogram,
    pub rx_rate_index_histograms_count: usize,
    pub snr_histograms_list: *const WlanFullmacSnrHistogram,
    pub snr_histograms_count: usize,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacImplBaseStartScanRequest {
    pub txn_id: u64,
    pub scan_type: WlanScanType,
    pub channels_list: *const u8,
    pub channels_count: usize,
    pub ssids_list: *const CSsid,
    pub ssids_count: usize,
    pub min_channel_time: u32,
    pub max_channel_time: u32,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacImplBaseConnectRequest {
    pub selected_bss: BssDescription,
    pub connect_failure_timeout: u32,
    pub auth_type: WlanAuthType,
    pub sae_password_list: *const u8,
    pub sae_password_count: usize,
    pub wep_key: WlanKeyConfig,
    pub security_ie_list: *const u8,
    pub security_ie_count: usize,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacImplBaseReconnectRequest {
    pub peer_sta_address: [u8; 6 as usize],
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacImplBaseAuthRespRequest {
    pub peer_sta_address: [u8; 6 as usize],
    pub result_code: WlanAuthResult,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacImplBaseDeauthRequest {
    pub peer_sta_address: [u8; 6 as usize],
    pub reason_code: ReasonCode,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacImplBaseAssocRespRequest {
    pub peer_sta_address: [u8; 6 as usize],
    pub result_code: WlanAssocResult,
    pub association_id: u16,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacImplBaseDisassocRequest {
    pub peer_sta_address: [u8; 6 as usize],
    pub reason_code: ReasonCode,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacImplBaseResetRequest {
    pub sta_address: [u8; 6 as usize],
    pub set_default_mib: bool,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacImplBaseStartBssRequest {
    pub ssid: CSsid,
    pub bss_type: BssType,
    pub beacon_period: u32,
    pub dtim_period: u32,
    pub channel: u8,
    pub rsne_list: *const u8,
    pub rsne_count: usize,
    pub vendor_ie_list: *const u8,
    pub vendor_ie_count: usize,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanFullmacImplBaseStopBssRequest {
    pub ssid: CSsid,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacImplBaseEapolTxRequest {
    pub src_addr: [u8; 6 as usize],
    pub dst_addr: [u8; 6 as usize],
    pub data_list: *const u8,
    pub data_count: usize,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanFullmacImplIfcBaseDeauthConfRequest {
    pub peer_sta_address: [u8; 6 as usize],
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct WlanAssocResult(pub u8);

impl WlanAssocResult {
    pub const SUCCESS: Self = Self(0);
    pub const REFUSED_REASON_UNSPECIFIED: Self = Self(1);
    pub const REFUSED_NOT_AUTHENTICATED: Self = Self(2);
    pub const REFUSED_CAPABILITIES_MISMATCH: Self = Self(3);
    pub const REFUSED_EXTERNAL_REASON: Self = Self(4);
    pub const REFUSED_AP_OUT_OF_MEMORY: Self = Self(5);
    pub const REFUSED_BASIC_RATES_MISMATCH: Self = Self(6);
    pub const REJECTED_EMERGENCY_SERVICES_NOT_SUPPORTED: Self = Self(7);
    pub const REFUSED_TEMPORARILY: Self = Self(8);
}

impl std::ops::BitAnd for WlanAssocResult {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl std::ops::BitAndAssign for WlanAssocResult {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Self(self.0 & rhs.0)
    }
}

impl std::ops::BitOr for WlanAssocResult {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl std::ops::BitOrAssign for WlanAssocResult {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 | rhs.0)
    }
}

impl std::ops::BitXor for WlanAssocResult {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl std::ops::BitXorAssign for WlanAssocResult {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 ^ rhs.0)
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct WlanAuthResult(pub u8);

impl WlanAuthResult {
    pub const SUCCESS: Self = Self(0);
    pub const REFUSED: Self = Self(1);
    pub const ANTI_CLOGGING_TOKEN_REQUIRED: Self = Self(2);
    pub const FINITE_CYCLIC_GROUP_NOT_SUPPORTED: Self = Self(3);
    pub const REJECTED: Self = Self(4);
    pub const FAILURE_TIMEOUT: Self = Self(5);
}

impl std::ops::BitAnd for WlanAuthResult {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl std::ops::BitAndAssign for WlanAuthResult {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Self(self.0 & rhs.0)
    }
}

impl std::ops::BitOr for WlanAuthResult {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl std::ops::BitOrAssign for WlanAuthResult {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 | rhs.0)
    }
}

impl std::ops::BitXor for WlanAuthResult {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl std::ops::BitXorAssign for WlanAuthResult {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 ^ rhs.0)
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct WlanAuthType(pub u8);

impl WlanAuthType {
    pub const OPEN_SYSTEM: Self = Self(1);
    pub const SHARED_KEY: Self = Self(2);
    pub const FAST_BSS_TRANSITION: Self = Self(3);
    pub const SAE: Self = Self(4);
}

impl std::ops::BitAnd for WlanAuthType {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl std::ops::BitAndAssign for WlanAuthType {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Self(self.0 & rhs.0)
    }
}

impl std::ops::BitOr for WlanAuthType {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl std::ops::BitOrAssign for WlanAuthType {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 | rhs.0)
    }
}

impl std::ops::BitXor for WlanAuthType {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl std::ops::BitXorAssign for WlanAuthType {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 ^ rhs.0)
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct WlanEapolResult(pub u8);

impl WlanEapolResult {
    pub const SUCCESS: Self = Self(0);
    pub const TRANSMISSION_FAILURE: Self = Self(1);
}

impl std::ops::BitAnd for WlanEapolResult {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl std::ops::BitAndAssign for WlanEapolResult {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Self(self.0 & rhs.0)
    }
}

impl std::ops::BitOr for WlanEapolResult {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl std::ops::BitOrAssign for WlanEapolResult {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 | rhs.0)
    }
}

impl std::ops::BitXor for WlanEapolResult {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl std::ops::BitXorAssign for WlanEapolResult {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 ^ rhs.0)
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct WlanFullmacAntennaFreq(pub u8);

impl WlanFullmacAntennaFreq {
    pub const ANTENNA_2_G: Self = Self(1);
    pub const ANTENNA_5_G: Self = Self(2);
}

impl std::ops::BitAnd for WlanFullmacAntennaFreq {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl std::ops::BitAndAssign for WlanFullmacAntennaFreq {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Self(self.0 & rhs.0)
    }
}

impl std::ops::BitOr for WlanFullmacAntennaFreq {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl std::ops::BitOrAssign for WlanFullmacAntennaFreq {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 | rhs.0)
    }
}

impl std::ops::BitXor for WlanFullmacAntennaFreq {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl std::ops::BitXorAssign for WlanFullmacAntennaFreq {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 ^ rhs.0)
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct WlanFullmacHistScope(pub u8);

impl WlanFullmacHistScope {
    pub const STATION: Self = Self(1);
    pub const PER_ANTENNA: Self = Self(2);
}

impl std::ops::BitAnd for WlanFullmacHistScope {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl std::ops::BitAndAssign for WlanFullmacHistScope {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Self(self.0 & rhs.0)
    }
}

impl std::ops::BitOr for WlanFullmacHistScope {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl std::ops::BitOrAssign for WlanFullmacHistScope {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 | rhs.0)
    }
}

impl std::ops::BitXor for WlanFullmacHistScope {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl std::ops::BitXorAssign for WlanFullmacHistScope {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 ^ rhs.0)
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct WlanScanType(pub u8);

impl WlanScanType {
    pub const ACTIVE: Self = Self(1);
    pub const PASSIVE: Self = Self(2);
}

impl std::ops::BitAnd for WlanScanType {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl std::ops::BitAndAssign for WlanScanType {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Self(self.0 & rhs.0)
    }
}

impl std::ops::BitOr for WlanScanType {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl std::ops::BitOrAssign for WlanScanType {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 | rhs.0)
    }
}

impl std::ops::BitXor for WlanScanType {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl std::ops::BitXorAssign for WlanScanType {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 ^ rhs.0)
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct WlanScanResult(pub u8);

impl WlanScanResult {
    pub const SUCCESS: Self = Self(0);
    pub const NOT_SUPPORTED: Self = Self(1);
    pub const INVALID_ARGS: Self = Self(2);
    pub const INTERNAL_ERROR: Self = Self(3);
    pub const SHOULD_WAIT: Self = Self(4);
    pub const CANCELED_BY_DRIVER_OR_FIRMWARE: Self = Self(5);
}

impl std::ops::BitAnd for WlanScanResult {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl std::ops::BitAndAssign for WlanScanResult {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Self(self.0 & rhs.0)
    }
}

impl std::ops::BitOr for WlanScanResult {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl std::ops::BitOrAssign for WlanScanResult {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 | rhs.0)
    }
}

impl std::ops::BitXor for WlanScanResult {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl std::ops::BitXorAssign for WlanScanResult {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 ^ rhs.0)
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct WlanStartResult(pub u8);

impl WlanStartResult {
    pub const SUCCESS: Self = Self(0);
    pub const BSS_ALREADY_STARTED_OR_JOINED: Self = Self(1);
    pub const RESET_REQUIRED_BEFORE_START: Self = Self(2);
    pub const NOT_SUPPORTED: Self = Self(3);
}

impl std::ops::BitAnd for WlanStartResult {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl std::ops::BitAndAssign for WlanStartResult {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Self(self.0 & rhs.0)
    }
}

impl std::ops::BitOr for WlanStartResult {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl std::ops::BitOrAssign for WlanStartResult {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 | rhs.0)
    }
}

impl std::ops::BitXor for WlanStartResult {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl std::ops::BitXorAssign for WlanStartResult {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 ^ rhs.0)
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct WlanStopResult(pub u8);

impl WlanStopResult {
    pub const SUCCESS: Self = Self(0);
    pub const BSS_ALREADY_STOPPED: Self = Self(1);
    pub const INTERNAL_ERROR: Self = Self(2);
}

impl std::ops::BitAnd for WlanStopResult {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl std::ops::BitAndAssign for WlanStopResult {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Self(self.0 & rhs.0)
    }
}

impl std::ops::BitOr for WlanStopResult {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl std::ops::BitOrAssign for WlanStopResult {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 | rhs.0)
    }
}

impl std::ops::BitXor for WlanStopResult {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl std::ops::BitXorAssign for WlanStopResult {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 ^ rhs.0)
    }
}