banjo_fuchsia_wlan_common/

banjo_fuchsia_wlan_common.rs

// 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

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


use banjo_fuchsia_wlan_ieee80211 as fuchsia_wlan_ieee80211;
use fuchsia_wlan_ieee80211::*;

pub const MAX_BANDS: u8 = 16;
pub const MAX_SUPPORTED_MAC_ROLES: u8 = 16;
pub const MAX_SUPPORTED_PHY_TYPES: u8 = 64;
pub const WLAN_MAC_MAX_EXT_RATES: u32 = 255;
pub const WLAN_MAC_MAX_SUPP_RATES: u32 = 8;
pub const WLAN_TX_RESULT_MAX_ENTRY: u32 = 8;
pub const WLAN_TX_VECTOR_IDX_INVALID: u16 = 0;
#[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)]
pub struct BssDescription {
    pub bssid: [u8; 6 as usize],
    pub bss_type: BssType,
    pub beacon_period: u16,
    pub capability_info: u16,
    pub ies_list: *const u8,
    pub ies_count: usize,
    pub channel: WlanChannel,
    pub rssi_dbm: i8,
    pub snr_db: i8,
}

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

#[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 ProbeResponseOffloadExtension {
    pub supported: bool,
}

#[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 DiscoverySupport {
    pub scan_offload: ScanOffloadExtension,
    pub probe_response_offload: ProbeResponseOffloadExtension,
}

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

#[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 MfpFeature {
    pub 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 SecuritySupport {
    pub sae: SaeFeature,
    pub mfp: MfpFeature,
}

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

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanTxResultEntry {
    pub tx_vector_idx: u16,
    pub attempts: u8,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanTxResult {
    pub tx_result_entry: [WlanTxResultEntry; 8 as usize],
    pub peer_addr: [u8; 6 as usize],
    pub result_code: WlanTxResultCode,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanWmmAccessCategoryParameters {
    pub ecw_min: u8,
    pub ecw_max: u8,
    pub aifsn: u8,
    pub txop_limit: u16,
    pub acm: bool,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct WlanWmmParameters {
    pub apsd: bool,
    pub ac_be_params: WlanWmmAccessCategoryParameters,
    pub ac_bk_params: WlanWmmAccessCategoryParameters,
    pub ac_vi_params: WlanWmmAccessCategoryParameters,
    pub ac_vo_params: WlanWmmAccessCategoryParameters,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct JoinBssRequest {
    pub bssid: [u8; 6 as usize],
    pub bss_type: BssType,
    pub remote: bool,
    pub beacon_period: u16,
}

#[repr(C)]
#[derive(Copy, Clone, Debug)]
pub struct WlanKeyConfig {
    pub protection: WlanProtection,
    pub cipher_oui: [u8; 3 as usize],
    pub cipher_type: CipherSuiteType,
    pub key_type: WlanKeyType,
    pub peer_addr: [u8; 6 as usize],
    pub key_idx: u8,
    pub key_list: *const u8,
    pub key_count: usize,
    pub rsc: u64,
}

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

impl BssType {
    pub const UNKNOWN: Self = Self(0);
    pub const INFRASTRUCTURE: Self = Self(1);
    pub const INDEPENDENT: Self = Self(2);
    pub const MESH: Self = Self(3);
    pub const PERSONAL: Self = Self(4);
}

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

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

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

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

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

impl std::ops::BitXorAssign for BssType {
    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(1);
    pub const CBW40: Self = Self(2);
    pub const CBW40BELOW: Self = Self(3);
    pub const CBW80: Self = Self(4);
    pub const CBW160: Self = Self(5);
    pub const CBW80P80: Self = Self(6);
}

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)
    }
}
#[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 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 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 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 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 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 WlanProtection(pub u8);

impl WlanProtection {
    pub const NONE: Self = Self(0);
    pub const RX: Self = Self(1);
    pub const TX: Self = Self(2);
    pub const RX_TX: Self = Self(3);
}

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

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

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

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

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

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

impl WlanKeyType {
    pub const PAIRWISE: Self = Self(1);
    pub const GROUP: Self = Self(2);
    pub const IGTK: Self = Self(3);
    pub const PEER: Self = Self(4);
}

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

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

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

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

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

impl std::ops::BitXorAssign for WlanKeyType {
    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 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 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 WlanTxResultCode(pub u8);

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

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

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

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

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

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

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