// 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.common banjo file

#![allow(unused_imports, non_camel_case_types)]


use banjo_fuchsia_wlan_ieee80211 as fuchsia_wlan_ieee80211;
use fuchsia_wlan_ieee80211::*;

pub const WLAN_TX_VECTOR_IDX_INVALID: u16 = 0;
pub const WLAN_TX_STATUS_MAX_ENTRY: u32 = 8;
pub const MAX_SUPPORTED_PHY_TYPES: u8 = 64;
pub const MAX_SUPPORTED_MAC_ROLES: u8 = 16;
pub const MAX_BANDS: u8 = 16;
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanTxStatusEntry {
    pub tx_vector_idx: u16,
    pub attempts: u8,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanTxStatus {
    pub tx_status_entry: [WlanTxStatusEntry; 8 as usize],
    pub peer_addr: [u8; 6 as usize],
    pub result: WlanTxResult,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct ScanOffloadExtension {
    pub supported: bool,
    pub scan_cancel_supported: bool,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct SaeFeature {
    pub driver_handler_supported: bool,
    pub sme_handler_supported: bool,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct RateSelectionOffloadExtension {
    pub supported: bool,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct ProbeResponseOffloadExtension {
    pub supported: bool,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct DiscoverySupport {
    pub scan_offload: ScanOffloadExtension,
    pub probe_response_offload: ProbeResponseOffloadExtension,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct MfpFeature {
    pub supported: bool,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct SecuritySupport {
    pub sae: SaeFeature,
    pub mfp: MfpFeature,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct DeviceExtension {
    pub is_synthetic: bool,
    pub mac_implementation_type: MacImplementationType,
    pub tx_status_report_supported: bool,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct DfsFeature {
    pub supported: bool,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct SpectrumManagementSupport {
    pub dfs: DfsFeature,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct DataPlaneExtension {
    pub data_plane_type: DataPlaneType,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct MacSublayerSupport {
    pub rate_selection_offload: RateSelectionOffloadExtension,
    pub data_plane: DataPlaneExtension,
    pub device: DeviceExtension,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanChannel {
    pub primary: u8,
    pub cbw: ChannelBandwidth,
    pub secondary80: u8,
}


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

impl WlanTxResult {
    pub const FAILED: Self = Self(0x0);
    pub const SUCCESS: Self = Self(0x1);
}

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

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

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

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

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

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

impl WlanSoftmacHardwareCapabilityBit {
    pub const SHORT_PREAMBLE: Self = Self(0x0020);
    pub const SPECTRUM_MGMT: Self = Self(0x0100);
    pub const QOS: Self = Self(0x0200);
    pub const SHORT_SLOT_TIME: Self = Self(0x0400);
    pub const RADIO_MSMT: Self = Self(0x1000);
    pub const SIMULTANEOUS_CLIENT_AP: Self = Self(0x10000);
}

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

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

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

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

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

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

impl WlanPhyType {
    pub const DSSS: Self = Self(1);
    pub const HR: Self = Self(2);
    pub const OFDM: Self = Self(3);
    pub const ERP: Self = Self(4);
    pub const HT: Self = Self(5);
    pub const DMG: Self = Self(6);
    pub const VHT: Self = Self(7);
    pub const TVHT: Self = Self(8);
    pub const S1G: Self = Self(9);
    pub const CDMG: Self = Self(10);
    pub const CMMG: Self = Self(11);
    pub const HE: Self = Self(12);
}

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

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

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

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

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

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

impl WlanMacRole {
    pub const CLIENT: Self = Self(1);
    pub const AP: Self = Self(2);
    pub const MESH: Self = Self(3);
}

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

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

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

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

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

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

impl WlanBand {
    pub const TWO_GHZ: Self = Self(0);
    pub const FIVE_GHZ: Self = Self(1);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

impl RequestStatus {
    pub const ACKNOWLEDGED: Self = Self(0);
    pub const REJECTED_NOT_SUPPORTED: Self = Self(1);
    pub const REJECTED_INCOMPATIBLE_MODE: Self = Self(2);
    pub const REJECTED_ALREADY_IN_USE: Self = Self(3);
    pub const REJECTED_DUPLICATE_REQUEST: Self = Self(4);
}

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

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

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

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

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

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

impl PowerSaveType {
    pub const PS_MODE_ULTRA_LOW_POWER: Self = Self(0x0);
    pub const PS_MODE_LOW_POWER: Self = Self(0x1);
    pub const PS_MODE_BALANCED: Self = Self(0x2);
    pub const PS_MODE_PERFORMANCE: Self = Self(0x3);
}

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

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

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

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

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

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

impl MacImplementationType {
    pub const SOFTMAC: Self = Self(1);
    pub const FULLMAC: Self = Self(2);
}

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

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

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

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

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

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

impl GuardInterval {
    pub const LONG_GI: Self = Self(1);
    pub const SHORT_GI: Self = Self(2);
}

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

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

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

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

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

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

impl DataPlaneType {
    pub const ETHERNET_DEVICE: Self = Self(1);
    pub const GENERIC_NETWORK_DEVICE: Self = Self(2);
}

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

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

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

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

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

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

impl ChannelBandwidth {
    pub const CBW20: Self = Self(0);
    pub const CBW40: Self = Self(1);
    pub const CBW40BELOW: Self = Self(2);
    pub const CBW80: Self = Self(3);
    pub const CBW160: Self = Self(4);
    pub const CBW80P80: Self = Self(5);
}

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

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

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

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

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

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