fidl_fuchsia_wlan_ieee80211__common/

fidl_fuchsia_wlan_ieee80211__common.rs

// WARNING: This file is machine generated by fidlgen.

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

pub type MacAddr = [u8; 6];

pub type Ssid = Vec<u8>;

pub const CCMP_128_MIC_LEN: u32 = 8;

pub const CCMP_256_MIC_LEN: u32 = 16;

/// IEEE Std 802.11-2016 12.5.3.2
pub const CCMP_HDR_LEN: u32 = 8;

pub const CCMP_PN_LEN: u32 = 6;

pub const HT_CAP_LEN: u8 = 26;

pub const HT_OP_LEN: u8 = 22;

pub const MAC_ADDR_LEN: u8 = 6;

pub const MAX_KEY_LEN: u8 = 32;

/// IEEE Std 802.11-2016, 9.4.2.99
pub const MAX_MESH_ID_BYTE_LEN: u8 = 32;

/// IEEE Std 802.11-2016, 9.3.3.2
pub const MAX_MGMT_FRAME_MAC_HEADER_BYTE_LEN: u8 = 28;

/// IEEE Std 802.11-2016, 9.2.4.7
pub const MAX_MMPDU_BYTE_LEN: u16 = 2304;

/// IEEE Std 802.11-2016, 9.4.2.2
/// The maximum length of an SSID is 32 bytes, even when the SSID should be
/// interpreted using UTF-8 encoding (see Table 9-135). While every length in
/// the 802.11 standard is byte oriented, the word BYTE is included in the
/// name of this constant to emphasize the importance that it not be applied
/// to the length of a UTF-8 encoded string.
pub const MAX_SSID_BYTE_LEN: u8 = 32;

pub const MAX_SUPPORTED_BASIC_RATES: u8 = 12;

/// The limit on the number of channels in a list of unique channel numbers is 256
/// since a channel number in IEEE 802.11-2016 cannot exceed one octet. See
/// IEEE 802.11-2016 9.4.2.18 Supported Channels element for an example element
/// that assumes a channel number does not exceed one octet.
pub const MAX_UNIQUE_CHANNEL_NUMBERS: u16 = 256;

pub const MAX_VHT_MPDU_BYTE_LEN_0: u16 = 3895;

pub const MAX_VHT_MPDU_BYTE_LEN_1: u16 = 7991;

pub const MAX_VHT_MPDU_BYTE_LEN_2: u16 = 11454;

pub const OUI_LEN: u8 = 3;

/// The limit on the number of SSIDs is 84 because an SSID List IE can contain no
/// more than 84 one byte SSIDs. (Specifying a zero byte SSID in an SSID List with
/// more than one SSID is valid but unnecessary since it is the wildcard SSID.)
pub const SSID_LIST_MAX: u8 = 84;

/// IEEE Std 802.11-2016, 9.2.4.5
pub const TIDS_MAX: u32 = 16;

pub const VHT_CAP_LEN: u8 = 12;

pub const VHT_OP_LEN: u8 = 5;

pub const WLAN_IE_BODY_MAX_LEN: u32 = 255;

/// IEEE Std 802.11-2016, 9.4.2.25.1
/// IEEE mentions that an element body maximum length is 255 octets in the RSN element
/// section, but not in a dedicated section.
/// Since the IE header is two octets, the whole IE max length is 257 octets.
pub const WLAN_IE_MAX_LEN: u32 = 257;

/// IEEE Std 802.11-2016, Table 9-19
pub const WLAN_MSDU_MAX_LEN: u32 = 2304;

/// Channel width is derived from the HT operation and VHT operation IEs,
/// or defaults to 20 MHz if not specified explicitly
///
/// IEEE Std 802.11-2016, Table 9-153 - HT/VHT Operation Information subfields
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum ChannelBandwidth {
    Cbw20,
    Cbw40,
    Cbw40Below,
    Cbw80,
    Cbw160,
    Cbw80P80,
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u32,
    },
}

/// Pattern that matches an unknown `ChannelBandwidth` member.
#[macro_export]
macro_rules! ChannelBandwidthUnknown {
    () => {
        _
    };
}

impl ChannelBandwidth {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::Cbw20),
            2 => Some(Self::Cbw40),
            3 => Some(Self::Cbw40Below),
            4 => Some(Self::Cbw80),
            5 => Some(Self::Cbw160),
            6 => Some(Self::Cbw80P80),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            1 => Self::Cbw20,
            2 => Self::Cbw40,
            3 => Self::Cbw40Below,
            4 => Self::Cbw80,
            5 => Self::Cbw160,
            6 => Self::Cbw80P80,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::Cbw20 => 1,
            Self::Cbw40 => 2,
            Self::Cbw40Below => 3,
            Self::Cbw80 => 4,
            Self::Cbw160 => 5,
            Self::Cbw80P80 => 6,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

/// IEEE Std 802.11-2016, 9.4.2.25.2
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum CipherSuiteType {
    UseGroup,
    Wep40,
    Tkip,
    Reserved3,
    Ccmp128,
    Wep104,
    BipCmac128,
    GroupAddressedNotAllowed,
    Gcmp128,
    Gcmp256,
    Ccmp256,
    BipGmac128,
    BipGmac256,
    BipCmac256,
    Reserved14To255,
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u32,
    },
}

/// Pattern that matches an unknown `CipherSuiteType` member.
#[macro_export]
macro_rules! CipherSuiteTypeUnknown {
    () => {
        _
    };
}

impl CipherSuiteType {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::UseGroup),
            1 => Some(Self::Wep40),
            2 => Some(Self::Tkip),
            3 => Some(Self::Reserved3),
            4 => Some(Self::Ccmp128),
            5 => Some(Self::Wep104),
            6 => Some(Self::BipCmac128),
            7 => Some(Self::GroupAddressedNotAllowed),
            8 => Some(Self::Gcmp128),
            9 => Some(Self::Gcmp256),
            10 => Some(Self::Ccmp256),
            11 => Some(Self::BipGmac128),
            12 => Some(Self::BipGmac256),
            13 => Some(Self::BipCmac256),
            14 => Some(Self::Reserved14To255),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            0 => Self::UseGroup,
            1 => Self::Wep40,
            2 => Self::Tkip,
            3 => Self::Reserved3,
            4 => Self::Ccmp128,
            5 => Self::Wep104,
            6 => Self::BipCmac128,
            7 => Self::GroupAddressedNotAllowed,
            8 => Self::Gcmp128,
            9 => Self::Gcmp256,
            10 => Self::Ccmp256,
            11 => Self::BipGmac128,
            12 => Self::BipGmac256,
            13 => Self::BipCmac256,
            14 => Self::Reserved14To255,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::UseGroup => 0,
            Self::Wep40 => 1,
            Self::Tkip => 2,
            Self::Reserved3 => 3,
            Self::Ccmp128 => 4,
            Self::Wep104 => 5,
            Self::BipCmac128 => 6,
            Self::GroupAddressedNotAllowed => 7,
            Self::Gcmp128 => 8,
            Self::Gcmp256 => 9,
            Self::Ccmp256 => 10,
            Self::BipGmac128 => 11,
            Self::BipGmac256 => 12,
            Self::BipCmac256 => 13,
            Self::Reserved14To255 => 14,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum KeyType {
    Pairwise,
    Group,
    Igtk,
    Peer,
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u8,
    },
}

/// Pattern that matches an unknown `KeyType` member.
#[macro_export]
macro_rules! KeyTypeUnknown {
    () => {
        _
    };
}

impl KeyType {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            1 => Some(Self::Pairwise),
            2 => Some(Self::Group),
            3 => Some(Self::Igtk),
            4 => Some(Self::Peer),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
        match prim {
            1 => Self::Pairwise,
            2 => Self::Group,
            3 => Self::Igtk,
            4 => Self::Peer,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        match self {
            Self::Pairwise => 1,
            Self::Group => 2,
            Self::Igtk => 3,
            Self::Peer => 4,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

/// 802.11 reason codes.  These values are common throughout the standard.
/// IEEE Std 802.11-2016, 9.4.1.7, Table 9-45
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum ReasonCode {
    UnspecifiedReason,
    InvalidAuthentication,
    LeavingNetworkDeauth,
    ReasonInactivity,
    NoMoreStas,
    InvalidClass2Frame,
    InvalidClass3Frame,
    LeavingNetworkDisassoc,
    NotAuthenticated,
    UnacceptablePowerCapability,
    UnacceptableSupportedChannels,
    BssTransitionDisassoc,
    ReasonInvalidElement,
    MicFailure,
    /// 15 is named "4WAY_HANDSHAKE_TIMEOUT" in 802.11-2016.
    FourwayHandshakeTimeout,
    GkHandshakeTimeout,
    HandshakeElementMismatch,
    ReasonInvalidGroupCipher,
    ReasonInvalidPairwiseCipher,
    ReasonInvalidAkmp,
    UnsupportedRsneVersion,
    InvalidRsneCapabilities,
    /// 23 is named "802_1_X_AUTH_FAILED" in 802.11-2016.
    Ieee8021XAuthFailed,
    ReasonCipherOutOfPolicy,
    TdlsPeerUnreachable,
    TdlsUnspecifiedReason,
    SspRequestedDisassoc,
    NoSspRoamingAgreement,
    BadCipherOrAkm,
    NotAuthorizedThisLocation,
    ServiceChangePrecludesTs,
    UnspecifiedQosReason,
    NotEnoughBandwidth,
    MissingAcks,
    ExceededTxop,
    StaLeaving,
    /// 37 is assigned to multiple names "END_TS", "END_BA", and "END_DLS" in 802.11-2016.
    EndTsBaDls,
    /// 38 is assigned to multiple names "UNKNOWN_TS" and "UNKNOWN_BA" in 802.11-2016.
    UnknownTsBa,
    Timeout,
    PeerkeyMismatch,
    PeerInitiated,
    ApInitiated,
    ReasonInvalidFtActionFrameCount,
    ReasonInvalidPmkid,
    ReasonInvalidMde,
    ReasonInvalidFte,
    MeshPeeringCanceled,
    MeshMaxPeers,
    MeshConfigurationPolicyViolation,
    MeshCloseRcvd,
    MeshMaxRetries,
    MeshConfirmTimeout,
    MeshInvalidGtk,
    MeshInconsistentParameters,
    MeshInvalidSecurityCapability,
    MeshPathErrorNoProxyInformation,
    MeshPathErrorNoForwardingInformation,
    MeshPathErrorDestinationUnreachable,
    MacAddressAlreadyExistsInMbss,
    MeshChannelSwitchRegulatoryRequirements,
    MeshChannelSwitchUnspecified,
    /// -----
    /// Values 67 to 127 are reserved by the IEEE protocol, and
    /// values 128 to 65535 are reserved for platform use.
    /// -----
    /// MLME lost the link, usually caused by loss of signal with the AP.
    MlmeLinkFailed,
    /// Driver detected a stalled Rx path in FW.
    FwRxStalled,
    /// Driver detected high wme rx error rate in FW.
    FwHighWmeRxErrRate,
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u16,
    },
}

/// Pattern that matches an unknown `ReasonCode` member.
#[macro_export]
macro_rules! ReasonCodeUnknown {
    () => {
        _
    };
}

impl ReasonCode {
    #[inline]
    pub fn from_primitive(prim: u16) -> Option<Self> {
        match prim {
            1 => Some(Self::UnspecifiedReason),
            2 => Some(Self::InvalidAuthentication),
            3 => Some(Self::LeavingNetworkDeauth),
            4 => Some(Self::ReasonInactivity),
            5 => Some(Self::NoMoreStas),
            6 => Some(Self::InvalidClass2Frame),
            7 => Some(Self::InvalidClass3Frame),
            8 => Some(Self::LeavingNetworkDisassoc),
            9 => Some(Self::NotAuthenticated),
            10 => Some(Self::UnacceptablePowerCapability),
            11 => Some(Self::UnacceptableSupportedChannels),
            12 => Some(Self::BssTransitionDisassoc),
            13 => Some(Self::ReasonInvalidElement),
            14 => Some(Self::MicFailure),
            15 => Some(Self::FourwayHandshakeTimeout),
            16 => Some(Self::GkHandshakeTimeout),
            17 => Some(Self::HandshakeElementMismatch),
            18 => Some(Self::ReasonInvalidGroupCipher),
            19 => Some(Self::ReasonInvalidPairwiseCipher),
            20 => Some(Self::ReasonInvalidAkmp),
            21 => Some(Self::UnsupportedRsneVersion),
            22 => Some(Self::InvalidRsneCapabilities),
            23 => Some(Self::Ieee8021XAuthFailed),
            24 => Some(Self::ReasonCipherOutOfPolicy),
            25 => Some(Self::TdlsPeerUnreachable),
            26 => Some(Self::TdlsUnspecifiedReason),
            27 => Some(Self::SspRequestedDisassoc),
            28 => Some(Self::NoSspRoamingAgreement),
            29 => Some(Self::BadCipherOrAkm),
            30 => Some(Self::NotAuthorizedThisLocation),
            31 => Some(Self::ServiceChangePrecludesTs),
            32 => Some(Self::UnspecifiedQosReason),
            33 => Some(Self::NotEnoughBandwidth),
            34 => Some(Self::MissingAcks),
            35 => Some(Self::ExceededTxop),
            36 => Some(Self::StaLeaving),
            37 => Some(Self::EndTsBaDls),
            38 => Some(Self::UnknownTsBa),
            39 => Some(Self::Timeout),
            45 => Some(Self::PeerkeyMismatch),
            46 => Some(Self::PeerInitiated),
            47 => Some(Self::ApInitiated),
            48 => Some(Self::ReasonInvalidFtActionFrameCount),
            49 => Some(Self::ReasonInvalidPmkid),
            50 => Some(Self::ReasonInvalidMde),
            51 => Some(Self::ReasonInvalidFte),
            52 => Some(Self::MeshPeeringCanceled),
            53 => Some(Self::MeshMaxPeers),
            54 => Some(Self::MeshConfigurationPolicyViolation),
            55 => Some(Self::MeshCloseRcvd),
            56 => Some(Self::MeshMaxRetries),
            57 => Some(Self::MeshConfirmTimeout),
            58 => Some(Self::MeshInvalidGtk),
            59 => Some(Self::MeshInconsistentParameters),
            60 => Some(Self::MeshInvalidSecurityCapability),
            61 => Some(Self::MeshPathErrorNoProxyInformation),
            62 => Some(Self::MeshPathErrorNoForwardingInformation),
            63 => Some(Self::MeshPathErrorDestinationUnreachable),
            64 => Some(Self::MacAddressAlreadyExistsInMbss),
            65 => Some(Self::MeshChannelSwitchRegulatoryRequirements),
            66 => Some(Self::MeshChannelSwitchUnspecified),
            128 => Some(Self::MlmeLinkFailed),
            129 => Some(Self::FwRxStalled),
            130 => Some(Self::FwHighWmeRxErrRate),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u16) -> Self {
        match prim {
            1 => Self::UnspecifiedReason,
            2 => Self::InvalidAuthentication,
            3 => Self::LeavingNetworkDeauth,
            4 => Self::ReasonInactivity,
            5 => Self::NoMoreStas,
            6 => Self::InvalidClass2Frame,
            7 => Self::InvalidClass3Frame,
            8 => Self::LeavingNetworkDisassoc,
            9 => Self::NotAuthenticated,
            10 => Self::UnacceptablePowerCapability,
            11 => Self::UnacceptableSupportedChannels,
            12 => Self::BssTransitionDisassoc,
            13 => Self::ReasonInvalidElement,
            14 => Self::MicFailure,
            15 => Self::FourwayHandshakeTimeout,
            16 => Self::GkHandshakeTimeout,
            17 => Self::HandshakeElementMismatch,
            18 => Self::ReasonInvalidGroupCipher,
            19 => Self::ReasonInvalidPairwiseCipher,
            20 => Self::ReasonInvalidAkmp,
            21 => Self::UnsupportedRsneVersion,
            22 => Self::InvalidRsneCapabilities,
            23 => Self::Ieee8021XAuthFailed,
            24 => Self::ReasonCipherOutOfPolicy,
            25 => Self::TdlsPeerUnreachable,
            26 => Self::TdlsUnspecifiedReason,
            27 => Self::SspRequestedDisassoc,
            28 => Self::NoSspRoamingAgreement,
            29 => Self::BadCipherOrAkm,
            30 => Self::NotAuthorizedThisLocation,
            31 => Self::ServiceChangePrecludesTs,
            32 => Self::UnspecifiedQosReason,
            33 => Self::NotEnoughBandwidth,
            34 => Self::MissingAcks,
            35 => Self::ExceededTxop,
            36 => Self::StaLeaving,
            37 => Self::EndTsBaDls,
            38 => Self::UnknownTsBa,
            39 => Self::Timeout,
            45 => Self::PeerkeyMismatch,
            46 => Self::PeerInitiated,
            47 => Self::ApInitiated,
            48 => Self::ReasonInvalidFtActionFrameCount,
            49 => Self::ReasonInvalidPmkid,
            50 => Self::ReasonInvalidMde,
            51 => Self::ReasonInvalidFte,
            52 => Self::MeshPeeringCanceled,
            53 => Self::MeshMaxPeers,
            54 => Self::MeshConfigurationPolicyViolation,
            55 => Self::MeshCloseRcvd,
            56 => Self::MeshMaxRetries,
            57 => Self::MeshConfirmTimeout,
            58 => Self::MeshInvalidGtk,
            59 => Self::MeshInconsistentParameters,
            60 => Self::MeshInvalidSecurityCapability,
            61 => Self::MeshPathErrorNoProxyInformation,
            62 => Self::MeshPathErrorNoForwardingInformation,
            63 => Self::MeshPathErrorDestinationUnreachable,
            64 => Self::MacAddressAlreadyExistsInMbss,
            65 => Self::MeshChannelSwitchRegulatoryRequirements,
            66 => Self::MeshChannelSwitchUnspecified,
            128 => Self::MlmeLinkFailed,
            129 => Self::FwRxStalled,
            130 => Self::FwHighWmeRxErrRate,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xffff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u16 {
        match self {
            Self::UnspecifiedReason => 1,
            Self::InvalidAuthentication => 2,
            Self::LeavingNetworkDeauth => 3,
            Self::ReasonInactivity => 4,
            Self::NoMoreStas => 5,
            Self::InvalidClass2Frame => 6,
            Self::InvalidClass3Frame => 7,
            Self::LeavingNetworkDisassoc => 8,
            Self::NotAuthenticated => 9,
            Self::UnacceptablePowerCapability => 10,
            Self::UnacceptableSupportedChannels => 11,
            Self::BssTransitionDisassoc => 12,
            Self::ReasonInvalidElement => 13,
            Self::MicFailure => 14,
            Self::FourwayHandshakeTimeout => 15,
            Self::GkHandshakeTimeout => 16,
            Self::HandshakeElementMismatch => 17,
            Self::ReasonInvalidGroupCipher => 18,
            Self::ReasonInvalidPairwiseCipher => 19,
            Self::ReasonInvalidAkmp => 20,
            Self::UnsupportedRsneVersion => 21,
            Self::InvalidRsneCapabilities => 22,
            Self::Ieee8021XAuthFailed => 23,
            Self::ReasonCipherOutOfPolicy => 24,
            Self::TdlsPeerUnreachable => 25,
            Self::TdlsUnspecifiedReason => 26,
            Self::SspRequestedDisassoc => 27,
            Self::NoSspRoamingAgreement => 28,
            Self::BadCipherOrAkm => 29,
            Self::NotAuthorizedThisLocation => 30,
            Self::ServiceChangePrecludesTs => 31,
            Self::UnspecifiedQosReason => 32,
            Self::NotEnoughBandwidth => 33,
            Self::MissingAcks => 34,
            Self::ExceededTxop => 35,
            Self::StaLeaving => 36,
            Self::EndTsBaDls => 37,
            Self::UnknownTsBa => 38,
            Self::Timeout => 39,
            Self::PeerkeyMismatch => 45,
            Self::PeerInitiated => 46,
            Self::ApInitiated => 47,
            Self::ReasonInvalidFtActionFrameCount => 48,
            Self::ReasonInvalidPmkid => 49,
            Self::ReasonInvalidMde => 50,
            Self::ReasonInvalidFte => 51,
            Self::MeshPeeringCanceled => 52,
            Self::MeshMaxPeers => 53,
            Self::MeshConfigurationPolicyViolation => 54,
            Self::MeshCloseRcvd => 55,
            Self::MeshMaxRetries => 56,
            Self::MeshConfirmTimeout => 57,
            Self::MeshInvalidGtk => 58,
            Self::MeshInconsistentParameters => 59,
            Self::MeshInvalidSecurityCapability => 60,
            Self::MeshPathErrorNoProxyInformation => 61,
            Self::MeshPathErrorNoForwardingInformation => 62,
            Self::MeshPathErrorDestinationUnreachable => 63,
            Self::MacAddressAlreadyExistsInMbss => 64,
            Self::MeshChannelSwitchRegulatoryRequirements => 65,
            Self::MeshChannelSwitchUnspecified => 66,
            Self::MlmeLinkFailed => 128,
            Self::FwRxStalled => 129,
            Self::FwHighWmeRxErrRate => 130,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

/// 802.11 status codes.  These values are common throughout the standard.
/// IEEE Std 802.11-2016, 9.4.1.9, Table 9-46
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u16)]
pub enum StatusCode {
    Success = 0,
    RefusedReasonUnspecified = 1,
    TdlsRejectedAlternativeProvided = 2,
    TdlsRejected = 3,
    /// 4 reserved.
    SecurityDisabled = 5,
    UnacceptableLifetime = 6,
    NotInSameBss = 7,
    /// 8-9 reserved.
    RefusedCapabilitiesMismatch = 10,
    DeniedNoAssociationExists = 11,
    DeniedOtherReason = 12,
    UnsupportedAuthAlgorithm = 13,
    TransactionSequenceError = 14,
    ChallengeFailure = 15,
    RejectedSequenceTimeout = 16,
    DeniedNoMoreStas = 17,
    RefusedBasicRatesMismatch = 18,
    DeniedNoShortPreambleSupport = 19,
    /// 20-21 reserved.
    RejectedSpectrumManagementRequired = 22,
    RejectedBadPowerCapability = 23,
    RejectedBadSupportedChannels = 24,
    DeniedNoShortSlotTimeSupport = 25,
    /// 26 reserved.
    DeniedNoHtSupport = 27,
    R0KhUnreachable = 28,
    DeniedPcoTimeNotSupported = 29,
    RefusedTemporarily = 30,
    RobustManagementPolicyViolation = 31,
    UnspecifiedQosFailure = 32,
    DeniedInsufficientBandwidth = 33,
    DeniedPoorChannelConditions = 34,
    DeniedQosNotSupported = 35,
    RequestDeclined = 37,
    InvalidParameters = 38,
    RejectedWithSuggestedChanges = 39,
    StatusInvalidElement = 40,
    StatusInvalidGroupCipher = 41,
    StatusInvalidPairwiseCipher = 42,
    StatusInvalidAkmp = 43,
    UnsupportedRsneVersion = 44,
    InvalidRsneCapabilities = 45,
    StatusCipherOutOfPolicy = 46,
    RejectedForDelayPeriod = 47,
    DlsNotAllowed = 48,
    NotPresent = 49,
    NotQosSta = 50,
    DeniedListenIntervalTooLarge = 51,
    StatusInvalidFtActionFrameCount = 52,
    StatusInvalidPmkid = 53,
    StatusInvalidMde = 54,
    StatusInvalidFte = 55,
    /// 56 is assigned to "REQUESTED_TCLAS_NOT_SUPPORTED_BY_AP" in 802.11-2016, duplicate with 80.
    /// Name below is as listed in the 802.11 Assigned Numbers Authority database.
    RequestedTclasNotSupportedByAp = 56,
    InsufficientTclasProcessingResources = 57,
    TryAnotherBss = 58,
    GasAdvertisementProtocolNotSupported = 59,
    NoOutstandingGasRequest = 60,
    GasResponseNotReceivedFromServer = 61,
    GasQueryTimeout = 62,
    GasQueryResponseTooLarge = 63,
    RejectedHomeWithSuggestedChanges = 64,
    ServerUnreachable = 65,
    /// 66 reserved.
    RejectedForSspPermissions = 67,
    RefusedUnauthenticatedAccessNotSupported = 68,
    /// 69-71 reserved.
    InvalidRsne = 72,
    UApsdCoexistanceNotSupported = 73,
    UApsdCoexModeNotSupported = 74,
    BadIntervalWithUApsdCoex = 75,
    AntiCloggingTokenRequired = 76,
    UnsupportedFiniteCyclicGroup = 77,
    CannotFindAlternativeTbtt = 78,
    TransmissionFailure = 79,
    /// See assignment for 56.
    RequestedTclasNotSupported = 80,
    TclasResourcesExhausted = 81,
    RejectedWithSuggestedBssTransition = 82,
    RejectWithSchedule = 83,
    RejectNoWakeupSpecified = 84,
    SuccessPowerSaveMode = 85,
    PendingAdmittingFstSession = 86,
    PerformingFstNow = 87,
    PendingGapInBaWindow = 88,
    RejectUPidSetting = 89,
    RefusedExternalReason = 92,
    RefusedApOutOfMemory = 93,
    RejectedEmergencyServicesNotSupported = 94,
    QueryResponseOutstanding = 95,
    RejectDseBand = 96,
    TclasProcessingTerminated = 97,
    TsScheduleConflict = 98,
    DeniedWithSuggestedBandAndChannel = 99,
    MccaopReservationConflict = 100,
    MafLimitExceeded = 101,
    MccaTrackLimitExceeded = 102,
    DeniedDueToSpectrumManagement = 103,
    DeniedVhtNotSupported = 104,
    EnablementDenied = 105,
    RestrictionFromAuthorizedGdb = 106,
    AuthorizationDeenabled = 107,
    /// Reserved values we will use for our own purposes.
    /// -----
    /// Failure when joining the BSS.
    JoinFailure = 256,
    /// Authenticate or associate fails due to spurious deauth or diassoc.
    SpuriousDeauthOrDisassoc = 257,
    /// Connect attempt is canceled
    Canceled = 258,
    /// Failure establishing security association
    EstablishRsnaFailure = 259,
}

impl StatusCode {
    #[inline]
    pub fn from_primitive(prim: u16) -> Option<Self> {
        match prim {
            0 => Some(Self::Success),
            1 => Some(Self::RefusedReasonUnspecified),
            2 => Some(Self::TdlsRejectedAlternativeProvided),
            3 => Some(Self::TdlsRejected),
            5 => Some(Self::SecurityDisabled),
            6 => Some(Self::UnacceptableLifetime),
            7 => Some(Self::NotInSameBss),
            10 => Some(Self::RefusedCapabilitiesMismatch),
            11 => Some(Self::DeniedNoAssociationExists),
            12 => Some(Self::DeniedOtherReason),
            13 => Some(Self::UnsupportedAuthAlgorithm),
            14 => Some(Self::TransactionSequenceError),
            15 => Some(Self::ChallengeFailure),
            16 => Some(Self::RejectedSequenceTimeout),
            17 => Some(Self::DeniedNoMoreStas),
            18 => Some(Self::RefusedBasicRatesMismatch),
            19 => Some(Self::DeniedNoShortPreambleSupport),
            22 => Some(Self::RejectedSpectrumManagementRequired),
            23 => Some(Self::RejectedBadPowerCapability),
            24 => Some(Self::RejectedBadSupportedChannels),
            25 => Some(Self::DeniedNoShortSlotTimeSupport),
            27 => Some(Self::DeniedNoHtSupport),
            28 => Some(Self::R0KhUnreachable),
            29 => Some(Self::DeniedPcoTimeNotSupported),
            30 => Some(Self::RefusedTemporarily),
            31 => Some(Self::RobustManagementPolicyViolation),
            32 => Some(Self::UnspecifiedQosFailure),
            33 => Some(Self::DeniedInsufficientBandwidth),
            34 => Some(Self::DeniedPoorChannelConditions),
            35 => Some(Self::DeniedQosNotSupported),
            37 => Some(Self::RequestDeclined),
            38 => Some(Self::InvalidParameters),
            39 => Some(Self::RejectedWithSuggestedChanges),
            40 => Some(Self::StatusInvalidElement),
            41 => Some(Self::StatusInvalidGroupCipher),
            42 => Some(Self::StatusInvalidPairwiseCipher),
            43 => Some(Self::StatusInvalidAkmp),
            44 => Some(Self::UnsupportedRsneVersion),
            45 => Some(Self::InvalidRsneCapabilities),
            46 => Some(Self::StatusCipherOutOfPolicy),
            47 => Some(Self::RejectedForDelayPeriod),
            48 => Some(Self::DlsNotAllowed),
            49 => Some(Self::NotPresent),
            50 => Some(Self::NotQosSta),
            51 => Some(Self::DeniedListenIntervalTooLarge),
            52 => Some(Self::StatusInvalidFtActionFrameCount),
            53 => Some(Self::StatusInvalidPmkid),
            54 => Some(Self::StatusInvalidMde),
            55 => Some(Self::StatusInvalidFte),
            56 => Some(Self::RequestedTclasNotSupportedByAp),
            57 => Some(Self::InsufficientTclasProcessingResources),
            58 => Some(Self::TryAnotherBss),
            59 => Some(Self::GasAdvertisementProtocolNotSupported),
            60 => Some(Self::NoOutstandingGasRequest),
            61 => Some(Self::GasResponseNotReceivedFromServer),
            62 => Some(Self::GasQueryTimeout),
            63 => Some(Self::GasQueryResponseTooLarge),
            64 => Some(Self::RejectedHomeWithSuggestedChanges),
            65 => Some(Self::ServerUnreachable),
            67 => Some(Self::RejectedForSspPermissions),
            68 => Some(Self::RefusedUnauthenticatedAccessNotSupported),
            72 => Some(Self::InvalidRsne),
            73 => Some(Self::UApsdCoexistanceNotSupported),
            74 => Some(Self::UApsdCoexModeNotSupported),
            75 => Some(Self::BadIntervalWithUApsdCoex),
            76 => Some(Self::AntiCloggingTokenRequired),
            77 => Some(Self::UnsupportedFiniteCyclicGroup),
            78 => Some(Self::CannotFindAlternativeTbtt),
            79 => Some(Self::TransmissionFailure),
            80 => Some(Self::RequestedTclasNotSupported),
            81 => Some(Self::TclasResourcesExhausted),
            82 => Some(Self::RejectedWithSuggestedBssTransition),
            83 => Some(Self::RejectWithSchedule),
            84 => Some(Self::RejectNoWakeupSpecified),
            85 => Some(Self::SuccessPowerSaveMode),
            86 => Some(Self::PendingAdmittingFstSession),
            87 => Some(Self::PerformingFstNow),
            88 => Some(Self::PendingGapInBaWindow),
            89 => Some(Self::RejectUPidSetting),
            92 => Some(Self::RefusedExternalReason),
            93 => Some(Self::RefusedApOutOfMemory),
            94 => Some(Self::RejectedEmergencyServicesNotSupported),
            95 => Some(Self::QueryResponseOutstanding),
            96 => Some(Self::RejectDseBand),
            97 => Some(Self::TclasProcessingTerminated),
            98 => Some(Self::TsScheduleConflict),
            99 => Some(Self::DeniedWithSuggestedBandAndChannel),
            100 => Some(Self::MccaopReservationConflict),
            101 => Some(Self::MafLimitExceeded),
            102 => Some(Self::MccaTrackLimitExceeded),
            103 => Some(Self::DeniedDueToSpectrumManagement),
            104 => Some(Self::DeniedVhtNotSupported),
            105 => Some(Self::EnablementDenied),
            106 => Some(Self::RestrictionFromAuthorizedGdb),
            107 => Some(Self::AuthorizationDeenabled),
            256 => Some(Self::JoinFailure),
            257 => Some(Self::SpuriousDeauthOrDisassoc),
            258 => Some(Self::Canceled),
            259 => Some(Self::EstablishRsnaFailure),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u16 {
        self as u16
    }
}

/// IEEE Std 802.11-2020 9.4.2.173
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum WlanAccessCategory {
    Background = 1,
    BestEffort = 2,
    Video = 3,
    Voice = 4,
}

impl WlanAccessCategory {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::Background),
            2 => Some(Self::BestEffort),
            3 => Some(Self::Video),
            4 => Some(Self::Voice),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }
}

/// Identifies a frequency band in metadata of various operations.
///
/// Examples of this enum in use are labeling scan results or reporting
/// a driver capabilities from various frequency bands.
///
/// NOTE: This enum is similar to the Band ID field defined in
/// IEEE Std 802.11-2016 9.4.1.46, but its values are not the same.
///
/// TODO(https://fxbug.dev/376442944): Create a spec-compliant Band ID type
/// and migrate the platform to use it.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum WlanBand {
    TwoGhz,
    FiveGhz,
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u8,
    },
}

/// Pattern that matches an unknown `WlanBand` member.
#[macro_export]
macro_rules! WlanBandUnknown {
    () => {
        _
    };
}

impl WlanBand {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            0 => Some(Self::TwoGhz),
            1 => Some(Self::FiveGhz),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
        match prim {
            0 => Self::TwoGhz,
            1 => Self::FiveGhz,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        match self {
            Self::TwoGhz => 0,
            Self::FiveGhz => 1,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CSsid {
    pub len: u8,
    pub data: [u8; 32],
}

impl fidl::Persistable for CSsid {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct HtCapabilities {
    pub bytes: [u8; 26],
}

impl fidl::Persistable for HtCapabilities {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct HtOperation {
    pub bytes: [u8; 22],
}

impl fidl::Persistable for HtOperation {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct VhtCapabilities {
    pub bytes: [u8; 12],
}

impl fidl::Persistable for VhtCapabilities {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct VhtOperation {
    pub bytes: [u8; 5],
}

impl fidl::Persistable for VhtOperation {}

/// Channel information derived from the DSSS parameter set, HT operation,
/// and VHT operation IEs, as well as the primary channel on which a frame
/// is received.
///
/// IEEE Std 802.11-2016, 9.4.2.4 - DSSS Parameter Set element
/// IEEE Std 802.11-2016, 9.4.2.57 - HT Operation element
/// IEEE Std 802.11-2016, 9.4.2.159 - VHT Operation element
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanChannel {
    pub primary: u8,
    pub cbw: ChannelBandwidth,
    pub secondary80: u8,
}

impl fidl::Persistable for WlanChannel {}

/// IEEE Std 802.11-2020 6.3.19.1.2
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SetKeyDescriptor {
    /// The key value as bytes.
    /// 802.11 specifies a bit string for this field, but we represent it as a byte array for
    /// convenience.
    /// Required.
    pub key: Option<Vec<u8>>,
    /// Index for rotating keys, e.g. group keys.
    /// This value is always 0 for key types which aren't rotating, e.g. pairwise keys.
    /// Required.
    pub key_id: Option<u16>,
    /// Whether this key is a pairwise, group or peer key.
    /// Required.
    pub key_type: Option<KeyType>,
    /// The peer MAC address for pairwise and peer keys.
    /// For group keys this value is always the broadcast address.
    /// Required.
    pub peer_addr: Option<[u8; 6]>,
    /// Receive Sequence Counter for group keys only.
    /// In all other cases the RSC will be 0.
    /// Optional.
    pub rsc: Option<u64>,
    /// IEEE Cipher suite selector. See IEEE Std 802.11-2016, 9.4.2.25.2, Table 9-131
    /// Required.
    pub cipher_oui: Option<[u8; 3]>,
    /// The cipher type.
    /// Required.
    pub cipher_type: Option<CipherSuiteType>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for SetKeyDescriptor {}

mod internal {
    use super::*;
    unsafe impl fidl::encoding::TypeMarker for ChannelBandwidth {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for ChannelBandwidth {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for ChannelBandwidth
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChannelBandwidth {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for CipherSuiteType {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for CipherSuiteType {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for CipherSuiteType
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CipherSuiteType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for KeyType {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u8>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u8>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for KeyType {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for KeyType {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for KeyType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u8>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ReasonCode {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u16>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u16>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for ReasonCode {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ReasonCode {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ReasonCode {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u16>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for StatusCode {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u16>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u16>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for StatusCode {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StatusCode {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StatusCode {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Success
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u16>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for WlanAccessCategory {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for WlanAccessCategory {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for WlanAccessCategory
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanAccessCategory {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Background
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for WlanBand {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u8>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u8>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for WlanBand {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanBand {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanBand {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u8>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for CSsid {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CSsid {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            1
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            33
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CSsid, D> for &CSsid {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CSsid>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut CSsid).write_unaligned((self as *const CSsid).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<u8, D>,
        T1: fidl::encoding::Encode<fidl::encoding::Array<u8, 32>, D>,
    > fidl::encoding::Encode<CSsid, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CSsid>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 1, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CSsid {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                len: fidl::new_empty!(u8, D),
                data: fidl::new_empty!(fidl::encoding::Array<u8, 32>, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 33);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for HtCapabilities {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for HtCapabilities {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            1
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            26
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HtCapabilities, D>
        for &HtCapabilities
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<HtCapabilities>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut HtCapabilities)
                    .write_unaligned((self as *const HtCapabilities).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 26>, D>,
    > fidl::encoding::Encode<HtCapabilities, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<HtCapabilities>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HtCapabilities {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { bytes: fidl::new_empty!(fidl::encoding::Array<u8, 26>, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 26);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for HtOperation {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for HtOperation {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            1
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            22
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HtOperation, D>
        for &HtOperation
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<HtOperation>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut HtOperation).write_unaligned((self as *const HtOperation).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 22>, D>,
    > fidl::encoding::Encode<HtOperation, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<HtOperation>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HtOperation {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { bytes: fidl::new_empty!(fidl::encoding::Array<u8, 22>, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 22);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for VhtCapabilities {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for VhtCapabilities {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            1
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            12
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VhtCapabilities, D>
        for &VhtCapabilities
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VhtCapabilities>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut VhtCapabilities)
                    .write_unaligned((self as *const VhtCapabilities).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 12>, D>,
    > fidl::encoding::Encode<VhtCapabilities, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VhtCapabilities>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VhtCapabilities {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { bytes: fidl::new_empty!(fidl::encoding::Array<u8, 12>, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 12);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for VhtOperation {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for VhtOperation {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            1
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            5
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VhtOperation, D>
        for &VhtOperation
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VhtOperation>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut VhtOperation)
                    .write_unaligned((self as *const VhtOperation).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 5>, D>,
    > fidl::encoding::Encode<VhtOperation, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VhtOperation>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VhtOperation {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { bytes: fidl::new_empty!(fidl::encoding::Array<u8, 5>, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 5);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for WlanChannel {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for WlanChannel {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            12
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WlanChannel, D>
        for &WlanChannel
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<WlanChannel>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<WlanChannel, D>::encode(
                (
                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary),
                    <ChannelBandwidth as fidl::encoding::ValueTypeMarker>::borrow(&self.cbw),
                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.secondary80),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<u8, D>,
        T1: fidl::encoding::Encode<ChannelBandwidth, D>,
        T2: fidl::encoding::Encode<u8, D>,
    > fidl::encoding::Encode<WlanChannel, D> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<WlanChannel>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u32).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                (ptr as *mut u32).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanChannel {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                primary: fidl::new_empty!(u8, D),
                cbw: fidl::new_empty!(ChannelBandwidth, D),
                secondary80: fidl::new_empty!(u8, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let mask = 0xffffff00u32;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let mask = 0xffffff00u32;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(u8, D, &mut self.primary, decoder, offset + 0, _depth)?;
            fidl::decode!(ChannelBandwidth, D, &mut self.cbw, decoder, offset + 4, _depth)?;
            fidl::decode!(u8, D, &mut self.secondary80, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

    impl SetKeyDescriptor {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.cipher_type {
                return 7;
            }
            if let Some(_) = self.cipher_oui {
                return 6;
            }
            if let Some(_) = self.rsc {
                return 5;
            }
            if let Some(_) = self.peer_addr {
                return 4;
            }
            if let Some(_) = self.key_type {
                return 3;
            }
            if let Some(_) = self.key_id {
                return 2;
            }
            if let Some(_) = self.key {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for SetKeyDescriptor {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for SetKeyDescriptor {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SetKeyDescriptor, D>
        for &SetKeyDescriptor
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SetKeyDescriptor>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
                self.key.as_ref().map(
                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<u16, D>(
                self.key_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<KeyType, D>(
                self.key_type.as_ref().map(<KeyType as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 4 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (4 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
                self.peer_addr
                    .as_ref()
                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 5 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (5 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<u64, D>(
                self.rsc.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 6 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (6 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 3>, D>(
                self.cipher_oui
                    .as_ref()
                    .map(<fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 7 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (7 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<CipherSuiteType, D>(
                self.cipher_type
                    .as_ref()
                    .map(<CipherSuiteType as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SetKeyDescriptor {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .key
                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.key_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <KeyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.key_type.get_or_insert_with(|| fidl::new_empty!(KeyType, D));
                fidl::decode!(KeyType, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 4 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .peer_addr
                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 5 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.rsc.get_or_insert_with(|| fidl::new_empty!(u64, D));
                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 6 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::Array<u8, 3> as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .cipher_oui
                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 3>, D));
                fidl::decode!(fidl::encoding::Array<u8, 3>, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 7 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <CipherSuiteType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.cipher_type.get_or_insert_with(|| fidl::new_empty!(CipherSuiteType, D));
                fidl::decode!(CipherSuiteType, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }
}