fidl_fuchsia_wlan_mlme__common/

fidl_fuchsia_wlan_mlme__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;

/// WFA WMM v1.2, 2.2.1
pub type QosInfo = u8;

pub const MAX_SSIDS_PER_SCAN_REQUEST: u32 = 32;

/// WFA WMM v1.2, 2.2.2 Table 5
/// Length of the WMM Parameter Element body. This does not include IE and vendor IE headers,
/// and only includes the QoS Info, reserved, and AC parameters fields.
pub const WMM_PARAM_LEN: u8 = 18;

pub const COUNTRY_ENVIRON_ALL: u8 = 32;

pub const COUNTRY_ENVIRON_INDOOR: u8 = 73;

pub const COUNTRY_ENVIRON_NON_COUNTRY: u8 = 88;

pub const COUNTRY_ENVIRON_OUTDOOR: u8 = 79;

bitflags! {
    /// Bits used to request management frame subtypes to be captured. Also used in
    /// StartCaptureFramesResponse to indicate what management frames are supported.
    ///
    /// These values are set at `1 << MgmtFrameSubtypeValue`
    /// See IEEE Std 802.11-2016, 9.2.4.1.3, for value of each management frame subtype
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct MgmtFrameCaptureFlags: u32 {
        const ASSOC_REQ = 1;
        const ASSOC_RESP = 2;
        const REASSOC_REQ = 4;
        const REASSOC_RESP = 8;
        const PROBE_REQ = 16;
        const PROBE_RESP = 32;
        const TIMING_AD = 64;
        const BEACON = 256;
        const ATIM = 512;
        const DISASSOC = 1024;
        const AUTH = 2048;
        const DEAUTH = 4096;
        const ACTION = 8192;
        const ACTION_NO_ACK = 16384;
    }
}

impl MgmtFrameCaptureFlags {}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum AssociateResultCode {
    Success = 0,
    RefusedReasonUnspecified = 1,
    RefusedNotAuthenticated = 2,
    RefusedCapabilitiesMismatch = 3,
    RefusedExternalReason = 4,
    RefusedApOutOfMemory = 5,
    RefusedBasicRatesMismatch = 6,
    RejectedEmergencyServicesNotSupported = 7,
    RefusedTemporarily = 8,
}

impl AssociateResultCode {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Success),
            1 => Some(Self::RefusedReasonUnspecified),
            2 => Some(Self::RefusedNotAuthenticated),
            3 => Some(Self::RefusedCapabilitiesMismatch),
            4 => Some(Self::RefusedExternalReason),
            5 => Some(Self::RefusedApOutOfMemory),
            6 => Some(Self::RefusedBasicRatesMismatch),
            7 => Some(Self::RejectedEmergencyServicesNotSupported),
            8 => Some(Self::RefusedTemporarily),
            _ => None,
        }
    }

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

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum AuthenticateResultCode {
    Success = 0,
    Refused = 1,
    AntiCloggingTokenRequired = 2,
    FiniteCyclicGroupNotSupported = 3,
    AuthenticationRejected = 4,
    AuthFailureTimeout = 5,
}

impl AuthenticateResultCode {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Success),
            1 => Some(Self::Refused),
            2 => Some(Self::AntiCloggingTokenRequired),
            3 => Some(Self::FiniteCyclicGroupNotSupported),
            4 => Some(Self::AuthenticationRejected),
            5 => Some(Self::AuthFailureTimeout),
            _ => None,
        }
    }

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

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum AuthenticationTypes {
    OpenSystem = 1,
    SharedKey = 2,
    FastBssTransition = 3,
    Sae = 4,
}

impl AuthenticationTypes {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::OpenSystem),
            2 => Some(Self::SharedKey),
            3 => Some(Self::FastBssTransition),
            4 => Some(Self::Sae),
            _ => None,
        }
    }

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

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ControlledPortState {
    Closed = 0,
    Open = 1,
}

impl ControlledPortState {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Closed),
            1 => Some(Self::Open),
            _ => None,
        }
    }

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

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum EapolResultCode {
    Success = 0,
    TransmissionFailure = 1,
}

impl EapolResultCode {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Success),
            1 => Some(Self::TransmissionFailure),
            _ => None,
        }
    }

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

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum KeyType {
    Group = 1,
    Pairwise = 2,
    PeerKey = 3,
    Igtk = 4,
}

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

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

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ScanResultCode {
    Success = 0,
    NotSupported = 1,
    InvalidArgs = 2,
    InternalError = 3,
    ShouldWait = 4,
    CanceledByDriverOrFirmware = 5,
}

impl ScanResultCode {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Success),
            1 => Some(Self::NotSupported),
            2 => Some(Self::InvalidArgs),
            3 => Some(Self::InternalError),
            4 => Some(Self::ShouldWait),
            5 => Some(Self::CanceledByDriverOrFirmware),
            _ => None,
        }
    }

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

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ScanTypes {
    Active = 1,
    Passive = 2,
}

impl ScanTypes {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::Active),
            2 => Some(Self::Passive),
            _ => None,
        }
    }

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

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum StartResultCode {
    Success = 0,
    BssAlreadyStartedOrJoined = 1,
    ResetRequiredBeforeStart = 2,
    NotSupported = 3,
    InternalError = 4,
}

impl StartResultCode {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Success),
            1 => Some(Self::BssAlreadyStartedOrJoined),
            2 => Some(Self::ResetRequiredBeforeStart),
            3 => Some(Self::NotSupported),
            4 => Some(Self::InternalError),
            _ => None,
        }
    }

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

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum StopResultCode {
    Success = 0,
    BssAlreadyStopped = 1,
    InternalError = 2,
}

impl StopResultCode {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Success),
            1 => Some(Self::BssAlreadyStopped),
            2 => Some(Self::InternalError),
            _ => None,
        }
    }

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

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AssociateIndication {
    pub peer_sta_address: [u8; 6],
    pub capability_info: u16,
    pub listen_interval: u16,
    pub ssid: Option<Vec<u8>>,
    pub rates: Vec<u8>,
    pub rsne: Option<Vec<u8>>,
}

impl fidl::Persistable for AssociateIndication {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AssociateResponse {
    pub peer_sta_address: [u8; 6],
    pub result_code: AssociateResultCode,
    pub association_id: u16,
    pub capability_info: u16,
    pub rates: Vec<u8>,
}

impl fidl::Persistable for AssociateResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AuthenticateIndication {
    pub peer_sta_address: [u8; 6],
    pub auth_type: AuthenticationTypes,
}

impl fidl::Persistable for AuthenticateIndication {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AuthenticateResponse {
    pub peer_sta_address: [u8; 6],
    pub result_code: AuthenticateResultCode,
}

impl fidl::Persistable for AuthenticateResponse {}

#[derive(Clone, Debug, PartialEq)]
pub struct BandCapability {
    /// The values of this struct apply to the band indicated in this field.
    pub band: fidl_fuchsia_wlan_ieee80211__common::WlanBand,
    /// Basic rates supported in units of 500 kbit/s (as defined in
    /// IEEE Std 802.11-2016, 9.4.2.3), e.g., 0x02 represents 1 Mbps.
    /// The value returned by this type indicates all the non-HT rates
    /// the device supports transmitting and receiving.
    pub basic_rates: Vec<u8>,
    pub ht_cap: Option<Box<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>>,
    pub vht_cap: Option<Box<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>>,
    /// A list of operating channels considered valid by hardware, in the context of
    /// regulatory information known to the device driver, at the time of its
    /// construction during iface creation. In this context, an operating channel
    /// means a channel which APs may transmit Beacon frames on in the current
    /// regulatory domain.
    ///
    /// This list should be used to determine efficacy of subsequent requests to
    /// scan a subset of channels using the iface, or to determine which operating
    /// channel to use when starting an AP.
    pub operating_channels: Vec<u8>,
}

impl fidl::Persistable for BandCapability {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CapturedFrameResult {
    pub frame: Vec<u8>,
}

impl fidl::Persistable for CapturedFrameResult {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ConnectConfirm {
    pub peer_sta_address: [u8; 6],
    pub result_code: fidl_fuchsia_wlan_ieee80211__common::StatusCode,
    pub association_id: u16,
    pub association_ies: Vec<u8>,
}

impl fidl::Persistable for ConnectConfirm {}

#[derive(Clone, Debug, PartialEq)]
pub struct ConnectRequest {
    pub selected_bss: fidl_fuchsia_wlan_common__common::BssDescription,
    pub connect_failure_timeout: u32,
    /// Additional parameters specific to the authentication exchange.
    pub auth_type: AuthenticationTypes,
    pub sae_password: Vec<u8>,
    /// WEP key used in the authentication exchange. Only included for WEP security type.
    pub wep_key: Option<Box<SetKeyDescriptor>>,
    /// Additional parameters specific to the association exchange.
    pub security_ie: Vec<u8>,
    /// OWE public key used for Diffie Hellman exchange during association.
    /// Only included for OWE security type.
    pub owe_public_key: Option<Box<fidl_fuchsia_wlan_internal__common::OwePublicKey>>,
}

impl fidl::Persistable for ConnectRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Country {
    pub alpha2: [u8; 2],
    pub suffix: u8,
}

impl fidl::Persistable for Country {}

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

impl fidl::Persistable for DeauthenticateConfirm {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeauthenticateIndication {
    pub peer_sta_address: [u8; 6],
    pub reason_code: fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
    /// locally_initiated is true if deauth is initiated from the device,
    /// and is false if it's initiated remotely (e.g. due to deauth frame)
    pub locally_initiated: bool,
}

impl fidl::Persistable for DeauthenticateIndication {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeauthenticateRequest {
    pub peer_sta_address: [u8; 6],
    pub reason_code: fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
}

impl fidl::Persistable for DeauthenticateRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeleteKeyDescriptor {
    pub key_id: u16,
    pub key_type: KeyType,
    pub address: [u8; 6],
}

impl fidl::Persistable for DeleteKeyDescriptor {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeleteKeysRequest {
    pub keylist: Vec<DeleteKeyDescriptor>,
}

impl fidl::Persistable for DeleteKeysRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct DeviceInfo {
    pub sta_addr: [u8; 6],
    pub factory_addr: [u8; 6],
    pub role: fidl_fuchsia_wlan_common__common::WlanMacRole,
    pub bands: Vec<BandCapability>,
    pub softmac_hardware_capability: u32,
    pub qos_capable: bool,
}

impl fidl::Persistable for DeviceInfo {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DisassociateConfirm {
    pub status: i32,
}

impl fidl::Persistable for DisassociateConfirm {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DisassociateIndication {
    pub peer_sta_address: [u8; 6],
    pub reason_code: fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
    /// locally_initiated is true if diassoc is initiated from the device,
    /// and is false if it's initiated remotely (e.g. due to disassoc frame)
    pub locally_initiated: bool,
}

impl fidl::Persistable for DisassociateIndication {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DisassociateRequest {
    pub peer_sta_address: [u8; 6],
    pub reason_code: fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
}

impl fidl::Persistable for DisassociateRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct EapolConfirm {
    pub result_code: EapolResultCode,
    /// This value corresponds to the dst_addr in the EapolRequest we're confirming.
    /// IEEE 802.11-2016 does not include this field, but we need it to disambiguate
    /// if multiple EAPoL handshakes are ongoing.
    pub dst_addr: [u8; 6],
}

impl fidl::Persistable for EapolConfirm {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct EapolIndication {
    pub src_addr: [u8; 6],
    pub dst_addr: [u8; 6],
    pub data: Vec<u8>,
}

impl fidl::Persistable for EapolIndication {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct EapolRequest {
    pub src_addr: [u8; 6],
    pub dst_addr: [u8; 6],
    pub data: Vec<u8>,
}

impl fidl::Persistable for EapolRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct MlmeGetSignalReportResponse {
    pub resp: fidl_fuchsia_wlan_stats__common::SignalReport,
}

impl fidl::Persistable for MlmeGetSignalReportResponse {}

#[derive(Clone, Debug, PartialEq)]
pub struct MlmeQueryTelemetrySupportResponse {
    pub resp: fidl_fuchsia_wlan_stats__common::TelemetrySupport,
}

impl fidl::Persistable for MlmeQueryTelemetrySupportResponse {}

#[derive(Clone, Debug, PartialEq)]
pub struct MinstrelListResponse {
    pub peers: fidl_fuchsia_wlan_minstrel__common::Peers,
}

impl fidl::Persistable for MinstrelListResponse {}

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

impl fidl::Persistable for MinstrelStatsRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct MinstrelStatsResponse {
    pub peer: Option<Box<fidl_fuchsia_wlan_minstrel__common::Peer>>,
}

impl fidl::Persistable for MinstrelStatsResponse {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeAssociateIndRequest {
    pub ind: AssociateIndication,
}

impl fidl::Persistable for MlmeAssociateIndRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeAssociateRespRequest {
    pub resp: AssociateResponse,
}

impl fidl::Persistable for MlmeAssociateRespRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeAuthenticateIndRequest {
    pub ind: AuthenticateIndication,
}

impl fidl::Persistable for MlmeAuthenticateIndRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeAuthenticateRespRequest {
    pub resp: AuthenticateResponse,
}

impl fidl::Persistable for MlmeAuthenticateRespRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeConnectConfRequest {
    pub resp: ConnectConfirm,
}

impl fidl::Persistable for MlmeConnectConfRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct MlmeConnectReqRequest {
    pub req: ConnectRequest,
}

impl fidl::Persistable for MlmeConnectReqRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct MlmeDeauthenticateConfRequest {
    pub resp: DeauthenticateConfirm,
}

impl fidl::Persistable for MlmeDeauthenticateConfRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeDeauthenticateIndRequest {
    pub ind: DeauthenticateIndication,
}

impl fidl::Persistable for MlmeDeauthenticateIndRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeDeauthenticateReqRequest {
    pub req: DeauthenticateRequest,
}

impl fidl::Persistable for MlmeDeauthenticateReqRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeDeleteKeysReqRequest {
    pub req: DeleteKeysRequest,
}

impl fidl::Persistable for MlmeDeleteKeysReqRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct MlmeDisassociateConfRequest {
    pub resp: DisassociateConfirm,
}

impl fidl::Persistable for MlmeDisassociateConfRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeDisassociateIndRequest {
    pub ind: DisassociateIndication,
}

impl fidl::Persistable for MlmeDisassociateIndRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeDisassociateReqRequest {
    pub req: DisassociateRequest,
}

impl fidl::Persistable for MlmeDisassociateReqRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeEapolConfRequest {
    pub resp: EapolConfirm,
}

impl fidl::Persistable for MlmeEapolConfRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeEapolIndRequest {
    pub ind: EapolIndication,
}

impl fidl::Persistable for MlmeEapolIndRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeEapolReqRequest {
    pub req: EapolRequest,
}

impl fidl::Persistable for MlmeEapolReqRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct MlmeFinalizeAssociationReqRequest {
    pub negotiated_capabilities: NegotiatedCapabilities,
}

impl fidl::Persistable for MlmeFinalizeAssociationReqRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct MlmeGetIfaceHistogramStatsResponse {
    pub resp: GetIfaceHistogramStatsResponse,
}

impl fidl::Persistable for MlmeGetIfaceHistogramStatsResponse {}

#[derive(Clone, Debug, PartialEq)]
pub struct MlmeGetIfaceStatsResponse {
    pub resp: GetIfaceStatsResponse,
}

impl fidl::Persistable for MlmeGetIfaceStatsResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct MlmeGetMinstrelStatsRequest {
    pub req: MinstrelStatsRequest,
}

impl fidl::Persistable for MlmeGetMinstrelStatsRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct MlmeGetMinstrelStatsResponse {
    pub resp: MinstrelStatsResponse,
}

impl fidl::Persistable for MlmeGetMinstrelStatsResponse {}

#[derive(Clone, Debug, PartialEq)]
pub struct MlmeListMinstrelPeersResponse {
    pub resp: MinstrelListResponse,
}

impl fidl::Persistable for MlmeListMinstrelPeersResponse {}

#[derive(Clone, Debug, PartialEq)]
pub struct MlmeOnChannelSwitchedRequest {
    pub info: fidl_fuchsia_wlan_internal__common::ChannelSwitchInfo,
}

impl fidl::Persistable for MlmeOnChannelSwitchedRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeOnPmkAvailableRequest {
    pub info: PmkInfo,
}

impl fidl::Persistable for MlmeOnPmkAvailableRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeOnSaeFrameRxRequest {
    pub frame: SaeFrame,
}

impl fidl::Persistable for MlmeOnSaeFrameRxRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct MlmeOnSaeHandshakeIndRequest {
    pub ind: SaeHandshakeIndication,
}

impl fidl::Persistable for MlmeOnSaeHandshakeIndRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeOnScanEndRequest {
    pub end: ScanEnd,
}

impl fidl::Persistable for MlmeOnScanEndRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct MlmeOnScanResultRequest {
    pub result: ScanResult,
}

impl fidl::Persistable for MlmeOnScanResultRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct MlmeOnWmmStatusRespRequest {
    pub status: i32,
    pub resp: fidl_fuchsia_wlan_internal__common::WmmStatusResponse,
}

impl fidl::Persistable for MlmeOnWmmStatusRespRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct MlmeQueryDeviceInfoResponse {
    pub info: DeviceInfo,
}

impl fidl::Persistable for MlmeQueryDeviceInfoResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct MlmeReconnectReqRequest {
    pub req: ReconnectRequest,
}

impl fidl::Persistable for MlmeReconnectReqRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeRelayCapturedFrameRequest {
    pub result: CapturedFrameResult,
}

impl fidl::Persistable for MlmeRelayCapturedFrameRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeResetReqRequest {
    pub req: ResetRequest,
}

impl fidl::Persistable for MlmeResetReqRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeRoamConfRequest {
    pub conf: RoamConfirm,
}

impl fidl::Persistable for MlmeRoamConfRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct MlmeRoamReqRequest {
    pub req: RoamRequest,
}

impl fidl::Persistable for MlmeRoamReqRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeRoamResultIndRequest {
    pub ind: RoamResultIndication,
}

impl fidl::Persistable for MlmeRoamResultIndRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct MlmeRoamStartIndRequest {
    pub ind: RoamStartIndication,
}

impl fidl::Persistable for MlmeRoamStartIndRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeSaeFrameTxRequest {
    pub frame: SaeFrame,
}

impl fidl::Persistable for MlmeSaeFrameTxRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeSaeHandshakeRespRequest {
    pub resp: SaeHandshakeResponse,
}

impl fidl::Persistable for MlmeSaeHandshakeRespRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeSetControlledPortRequest {
    pub req: SetControlledPortRequest,
}

impl fidl::Persistable for MlmeSetControlledPortRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeSetKeysConfRequest {
    pub conf: SetKeysConfirm,
}

impl fidl::Persistable for MlmeSetKeysConfRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeSetKeysReqRequest {
    pub req: SetKeysRequest,
}

impl fidl::Persistable for MlmeSetKeysReqRequest {}

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

impl fidl::Persistable for MlmeSetMacAddressRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct MlmeSignalReportRequest {
    pub ind: fidl_fuchsia_wlan_internal__common::SignalReportIndication,
}

impl fidl::Persistable for MlmeSignalReportRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeStartCaptureFramesRequest {
    pub req: StartCaptureFramesRequest,
}

impl fidl::Persistable for MlmeStartCaptureFramesRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeStartCaptureFramesResponse {
    pub resp: StartCaptureFramesResponse,
}

impl fidl::Persistable for MlmeStartCaptureFramesResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeStartConfRequest {
    pub resp: StartConfirm,
}

impl fidl::Persistable for MlmeStartConfRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeStartReqRequest {
    pub req: StartRequest,
}

impl fidl::Persistable for MlmeStartReqRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeStartScanRequest {
    pub req: ScanRequest,
}

impl fidl::Persistable for MlmeStartScanRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeStopConfRequest {
    pub resp: StopConfirm,
}

impl fidl::Persistable for MlmeStopConfRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MlmeStopReqRequest {
    pub req: StopRequest,
}

impl fidl::Persistable for MlmeStopReqRequest {}

/// Non-IEEE custom structure to inform a SoftMAC device about the association negotiation outcome.
#[derive(Clone, Debug, PartialEq)]
pub struct NegotiatedCapabilities {
    pub channel: fidl_fuchsia_wlan_ieee80211__common::WlanChannel,
    pub capability_info: u16,
    pub rates: Vec<u8>,
    pub wmm_param: Option<Box<WmmParameter>>,
    pub ht_cap: Option<Box<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>>,
    pub vht_cap: Option<Box<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>>,
}

impl fidl::Persistable for NegotiatedCapabilities {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PmkInfo {
    pub pmk: Vec<u8>,
    pub pmkid: Vec<u8>,
}

impl fidl::Persistable for PmkInfo {}

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

impl fidl::Persistable for ReconnectRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ResetRequest {
    pub sta_address: [u8; 6],
    pub set_default_mib: bool,
}

impl fidl::Persistable for ResetRequest {}

/// Result of an SME-initiated roam attempt.
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RoamConfirm {
    pub selected_bssid: [u8; 6],
    pub status_code: fidl_fuchsia_wlan_ieee80211__common::StatusCode,
    /// Whether the original BSS association has been maintained through the roam attempt.
    /// A successful roam always incurs disassociation from the original BSS, so if `status_code` is
    /// success then this field must be set to false; a roam failure typically incurs disassociation
    /// from the original BSS, but may not in some cases (e.g. in some Fast BSS Transition scenarios).
    pub original_association_maintained: bool,
    /// Whether the client is authenticated with the target BSS. If `status_code` is success, then
    /// this field must be set to true; if the roam attempt failed, this field may be true or false.
    /// This allows higher layers to decide how to clean up connection state after a failed roam
    /// attempt.
    pub target_bss_authenticated: bool,
    pub association_id: u16,
    pub association_ies: Vec<u8>,
}

impl fidl::Persistable for RoamConfirm {}

#[derive(Clone, Debug, PartialEq)]
pub struct RoamRequest {
    pub selected_bss: fidl_fuchsia_wlan_common__common::BssDescription,
}

impl fidl::Persistable for RoamRequest {}

/// Result of a fullmac-initiated roam attempt.
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RoamResultIndication {
    pub selected_bssid: [u8; 6],
    pub status_code: fidl_fuchsia_wlan_ieee80211__common::StatusCode,
    /// Whether the original BSS association has been maintained through the roam attempt.
    /// A successful roam always incurs disassociation from the original BSS, so if `status_code` is
    /// success then this field must be set to false; a roam failure typically incurs disassociation
    /// from the original BSS, but may not in some cases (e.g. in some Fast BSS Transition scenarios).
    pub original_association_maintained: bool,
    /// Whether the client is authenticated with the target BSS. If `status_code` is success, then
    /// this field must be set to true; if the roam attempt failed, this field may be true or false.
    /// This allows higher layers to decide how to clean up connection state after a failed roam
    /// attempt.
    pub target_bss_authenticated: bool,
    pub association_id: u16,
    pub association_ies: Vec<u8>,
}

impl fidl::Persistable for RoamResultIndication {}

/// In-progress fullmac-initiated roam attempt details.
#[derive(Clone, Debug, PartialEq)]
pub struct RoamStartIndication {
    pub selected_bssid: [u8; 6],
    pub selected_bss: fidl_fuchsia_wlan_common__common::BssDescription,
    /// Whether the original BSS association has been maintained at the start of a roam attempt.
    /// 802.11 dictates that a STA can only be associated with a single BSS, so a roam attempt
    /// typically incurs disassociation at the start of the roam attempt. However, 802.11 also
    /// provides a mechanism (i.e. Fast BSS Transition) that allows a device to maintain
    /// association with the original BSS while establishing authentication with the target BSS, in
    /// order to avoid losing the original association if authentication with the target BSS fails.
    pub original_association_maintained: bool,
}

impl fidl::Persistable for RoamStartIndication {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SaeFrame {
    pub peer_sta_address: [u8; 6],
    pub status_code: fidl_fuchsia_wlan_ieee80211__common::StatusCode,
    pub seq_num: u16,
    pub sae_fields: Vec<u8>,
}

impl fidl::Persistable for SaeFrame {}

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

impl fidl::Persistable for SaeHandshakeIndication {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SaeHandshakeResponse {
    pub peer_sta_address: [u8; 6],
    pub status_code: fidl_fuchsia_wlan_ieee80211__common::StatusCode,
}

impl fidl::Persistable for SaeHandshakeResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ScanEnd {
    pub txn_id: u64,
    pub code: ScanResultCode,
}

impl fidl::Persistable for ScanEnd {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ScanRequest {
    pub txn_id: u64,
    pub scan_type: ScanTypes,
    /// List of channels to scan on. An empty list of channels will cause a
    /// scan request to immediately return a ScanEnd with code INVALID_ARGS.
    ///
    /// Invalid channel numbers will be silently ignored. The validity of a channel
    /// number depends on the current regulatory region, and MLME does not control
    /// or know this setting.
    pub channel_list: Vec<u8>,
    /// List of SSIDs to scan for. An empty list of ssids is the same as specifying
    /// a list containing only the wildcard SSID.
    ///
    /// There is no limit on the number of SSIDs specified. A large number of
    /// SSIDs may result in extended scan times because of hardware limitations on
    /// the number of SSIDs permitted per scan request and the technical limitation
    /// in IEEE 802.11-2016 that limits the number of SSIDs in a single Probe Request
    /// frame to ieee80211.SSID_LIST_MAX SSIDs.
    pub ssid_list: Vec<Vec<u8>>,
    pub probe_delay: u32,
    pub min_channel_time: u32,
    pub max_channel_time: u32,
}

impl fidl::Persistable for ScanRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct ScanResult {
    pub txn_id: u64,
    pub timestamp_nanos: i64,
    pub bss: fidl_fuchsia_wlan_common__common::BssDescription,
}

impl fidl::Persistable for ScanResult {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SetControlledPortRequest {
    pub peer_sta_address: [u8; 6],
    pub state: ControlledPortState,
}

impl fidl::Persistable for SetControlledPortRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SetKeyDescriptor {
    pub key: Vec<u8>,
    pub key_id: u16,
    pub key_type: KeyType,
    pub address: [u8; 6],
    pub rsc: u64,
    pub cipher_suite_oui: [u8; 3],
    pub cipher_suite_type: fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType,
}

impl fidl::Persistable for SetKeyDescriptor {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SetKeyResult {
    pub key_id: u16,
    pub status: i32,
}

impl fidl::Persistable for SetKeyResult {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SetKeysConfirm {
    pub results: Vec<SetKeyResult>,
}

impl fidl::Persistable for SetKeysConfirm {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SetKeysRequest {
    pub keylist: Vec<SetKeyDescriptor>,
}

impl fidl::Persistable for SetKeysRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct StartCaptureFramesRequest {
    pub mgmt_frame_flags: MgmtFrameCaptureFlags,
}

impl fidl::Persistable for StartCaptureFramesRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct StartCaptureFramesResponse {
    pub status: i32,
    pub supported_mgmt_frames: MgmtFrameCaptureFlags,
}

impl fidl::Persistable for StartCaptureFramesResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct StartConfirm {
    pub result_code: StartResultCode,
}

impl fidl::Persistable for StartConfirm {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct StartRequest {
    pub ssid: Vec<u8>,
    pub bss_type: fidl_fuchsia_wlan_common__common::BssType,
    pub beacon_period: u16,
    pub dtim_period: u8,
    pub channel: u8,
    pub capability_info: u16,
    pub rates: Vec<u8>,
    pub country: Country,
    pub mesh_id: Vec<u8>,
    pub rsne: Option<Vec<u8>>,
    pub phy: fidl_fuchsia_wlan_common__common::WlanPhyType,
    pub channel_bandwidth: fidl_fuchsia_wlan_ieee80211__common::ChannelBandwidth,
}

impl fidl::Persistable for StartRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct StopConfirm {
    pub result_code: StopResultCode,
}

impl fidl::Persistable for StopConfirm {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct StopRequest {
    pub ssid: Vec<u8>,
}

impl fidl::Persistable for StopRequest {}

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

impl fidl::Persistable for WmmParameter {}

#[derive(Clone, Debug, PartialEq)]
pub enum GetIfaceHistogramStatsResponse {
    Stats(fidl_fuchsia_wlan_stats__common::IfaceHistogramStats),
    ErrorStatus(i32),
}

impl GetIfaceHistogramStatsResponse {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Stats(_) => 1,
            Self::ErrorStatus(_) => 2,
        }
    }
}

impl fidl::Persistable for GetIfaceHistogramStatsResponse {}

#[derive(Clone, Debug, PartialEq)]
pub enum GetIfaceStatsResponse {
    Stats(fidl_fuchsia_wlan_stats__common::IfaceStats),
    ErrorStatus(i32),
}

impl GetIfaceStatsResponse {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Stats(_) => 1,
            Self::ErrorStatus(_) => 2,
        }
    }
}

impl fidl::Persistable for GetIfaceStatsResponse {}

pub mod connector_ordinals {
    pub const CONNECT: u64 = 0x42131859717af962;
}

pub mod mlme_ordinals {
    pub const START_SCAN: u64 = 0x342cc5ec6a957479;
    pub const ON_SCAN_RESULT: u64 = 0x681af7466a75074d;
    pub const ON_SCAN_END: u64 = 0x7f2702d253e7ca59;
    pub const CONNECT_REQ: u64 = 0x31153dc85f8f64c;
    pub const CONNECT_CONF: u64 = 0x77b27623279b981e;
    pub const RECONNECT_REQ: u64 = 0x74e0f1bd758b6b78;
    pub const ROAM_REQ: u64 = 0x3ba163eadf7dba45;
    pub const ROAM_CONF: u64 = 0x3f608034faa054bc;
    pub const ROAM_START_IND: u64 = 0x270a1ec78672d094;
    pub const ROAM_RESULT_IND: u64 = 0x26d074364fc84865;
    pub const AUTHENTICATE_IND: u64 = 0x460f49ae891adbe9;
    pub const AUTHENTICATE_RESP: u64 = 0x26108aade2fdd2f4;
    pub const DEAUTHENTICATE_REQ: u64 = 0x228983b200de5d12;
    pub const DEAUTHENTICATE_CONF: u64 = 0x3b44debc21b88c8c;
    pub const DEAUTHENTICATE_IND: u64 = 0x7ee0889b326da1d7;
    pub const ASSOCIATE_IND: u64 = 0x6a86f20e3063dd63;
    pub const ASSOCIATE_RESP: u64 = 0x70244dbd652ed6d9;
    pub const DISASSOCIATE_REQ: u64 = 0x5765807f1387d764;
    pub const DISASSOCIATE_CONF: u64 = 0x61345fbce732a28d;
    pub const DISASSOCIATE_IND: u64 = 0x77ac0ebf387c1f35;
    pub const RESET_REQ: u64 = 0x780b98c58a286b9f;
    pub const START_REQ: u64 = 0x5d95885f8053654;
    pub const START_CONF: u64 = 0x15ea6cdf3b8382b3;
    pub const STOP_REQ: u64 = 0x27b9a2ab04a2c79f;
    pub const STOP_CONF: u64 = 0x50b426ef4a84a2df;
    pub const SET_KEYS_REQ: u64 = 0x6b30a07fd3a11a79;
    pub const SET_KEYS_CONF: u64 = 0x5bafb3a8d4039380;
    pub const DELETE_KEYS_REQ: u64 = 0x1e3524d20d190c8f;
    pub const EAPOL_REQ: u64 = 0xc3c096924704d4;
    pub const EAPOL_CONF: u64 = 0x6ffa21f4ee73ce64;
    pub const SIGNAL_REPORT: u64 = 0x48f32a876aa53d8f;
    pub const EAPOL_IND: u64 = 0x7038dca46a3142fc;
    pub const SET_CONTROLLED_PORT: u64 = 0x4e47065668890c8d;
    pub const QUERY_DEVICE_INFO: u64 = 0x6ee3e7f63f2b7bc0;
    pub const QUERY_TELEMETRY_SUPPORT: u64 = 0x1598879b70332c99;
    pub const GET_IFACE_STATS: u64 = 0xede1a8342d1b211;
    pub const GET_IFACE_HISTOGRAM_STATS: u64 = 0x1979c9d3449f8675;
    pub const GET_SIGNAL_REPORT: u64 = 0x7e47e7ebe92acec9;
    pub const LIST_MINSTREL_PEERS: u64 = 0x4ac5d1e66fe1ffd5;
    pub const GET_MINSTREL_STATS: u64 = 0x2f688b1245323f4b;
    pub const START_CAPTURE_FRAMES: u64 = 0x23b369ed5749ee69;
    pub const STOP_CAPTURE_FRAMES: u64 = 0x2f1aebbc68bf7c54;
    pub const RELAY_CAPTURED_FRAME: u64 = 0x6f00a6f3cff9b1f5;
    pub const ON_CHANNEL_SWITCHED: u64 = 0x581750594e4c0c1;
    pub const ON_PMK_AVAILABLE: u64 = 0x1314fc2c79643f90;
    pub const ON_SAE_HANDSHAKE_IND: u64 = 0x6308b10e18986d7e;
    pub const SAE_HANDSHAKE_RESP: u64 = 0x28477bd2f7a5ab0c;
    pub const SAE_FRAME_TX: u64 = 0x7700c0d536733d8c;
    pub const ON_SAE_FRAME_RX: u64 = 0x4ebf51c86ef5f3cd;
    pub const WMM_STATUS_REQ: u64 = 0xef4851f6088fede;
    pub const ON_WMM_STATUS_RESP: u64 = 0x53f056b432e7b5cb;
    pub const FINALIZE_ASSOCIATION_REQ: u64 = 0x7aea59787cfd385a;
    pub const SET_MAC_ADDRESS: u64 = 0x476999f9bb27afe1;
}

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

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

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

    impl fidl::encoding::ValueTypeMarker for MgmtFrameCaptureFlags {
        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 MgmtFrameCaptureFlags
    {
        #[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);
            if self.bits() & Self::all().bits() != self.bits() {
                return Err(fidl::Error::InvalidBitsValue);
            }
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

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

        #[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_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for AssociateResultCode {
        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 AssociateResultCode {
        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 AssociateResultCode
    {
        #[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 AssociateResultCode {
        #[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::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for AuthenticateResultCode {
        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 AuthenticateResultCode {
        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 AuthenticateResultCode
    {
        #[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 AuthenticateResultCode
    {
        #[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::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for AuthenticationTypes {
        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 AuthenticationTypes {
        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 AuthenticationTypes
    {
        #[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 AuthenticationTypes {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::OpenSystem
        }

        #[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 ControlledPortState {
        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 ControlledPortState {
        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 ControlledPortState
    {
        #[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 ControlledPortState {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Closed
        }

        #[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 EapolResultCode {
        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 EapolResultCode {
        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 EapolResultCode
    {
        #[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 EapolResultCode {
        #[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::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            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::<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 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::Group
        }

        #[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 ScanResultCode {
        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 ScanResultCode {
        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 ScanResultCode {
        #[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 ScanResultCode {
        #[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::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ScanTypes {
        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 ScanTypes {
        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 ScanTypes {
        #[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 ScanTypes {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Active
        }

        #[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 StartResultCode {
        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 StartResultCode {
        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 StartResultCode
    {
        #[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 StartResultCode {
        #[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::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for StopResultCode {
        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 StopResultCode {
        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 StopResultCode {
        #[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 StopResultCode {
        #[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::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AssociateIndication, D>
        for &AssociateIndication
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AssociateIndication>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AssociateIndication, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.capability_info),
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.listen_interval),
                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 32>> as fidl::encoding::ValueTypeMarker>::borrow(&self.ssid),
                    <fidl::encoding::Vector<u8, 14> as fidl::encoding::ValueTypeMarker>::borrow(&self.rates),
                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>> as fidl::encoding::ValueTypeMarker>::borrow(&self.rsne),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<u16, D>,
        T2: fidl::encoding::Encode<u16, D>,
        T3: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::Vector<u8, 32>>, D>,
        T4: fidl::encoding::Encode<fidl::encoding::Vector<u8, 14>, D>,
        T5: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>>, D>,
    > fidl::encoding::Encode<AssociateIndication, D> for (T0, T1, T2, T3, T4, T5)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AssociateIndication>(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(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 6, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 16, depth)?;
            self.4.encode(encoder, offset + 32, depth)?;
            self.5.encode(encoder, offset + 48, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AssociateIndication {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                capability_info: fidl::new_empty!(u16, D),
                listen_interval: fidl::new_empty!(u16, D),
                ssid: fidl::new_empty!(fidl::encoding::Optional<fidl::encoding::Vector<u8, 32>>, D),
                rates: fidl::new_empty!(fidl::encoding::Vector<u8, 14>, D),
                rsne: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>>,
                    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(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffffffff0000u64;
            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!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
            fidl::decode!(u16, D, &mut self.capability_info, decoder, offset + 6, _depth)?;
            fidl::decode!(u16, D, &mut self.listen_interval, decoder, offset + 8, _depth)?;
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::Vector<u8, 32>>,
                D,
                &mut self.ssid,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(fidl::encoding::Vector<u8, 14>, D, &mut self.rates, decoder, offset + 32, _depth)?;
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>>,
                D,
                &mut self.rsne,
                decoder,
                offset + 48,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AssociateResponse, D>
        for &AssociateResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AssociateResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AssociateResponse, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.peer_sta_address,
                    ),
                    <AssociateResultCode as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.result_code,
                    ),
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.association_id),
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.capability_info),
                    <fidl::encoding::Vector<u8, 14> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.rates,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<AssociateResultCode, D>,
        T2: fidl::encoding::Encode<u16, D>,
        T3: fidl::encoding::Encode<u16, D>,
        T4: fidl::encoding::Encode<fidl::encoding::Vector<u8, 14>, D>,
    > fidl::encoding::Encode<AssociateResponse, D> for (T0, T1, T2, T3, T4)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AssociateResponse>(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 u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 12, depth)?;
            self.3.encode(encoder, offset + 14, depth)?;
            self.4.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AssociateResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                result_code: fidl::new_empty!(AssociateResultCode, D),
                association_id: fidl::new_empty!(u16, D),
                capability_info: fidl::new_empty!(u16, D),
                rates: fidl::new_empty!(fidl::encoding::Vector<u8, 14>, 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 u64).read_unaligned() };
            let mask = 0xffff000000000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
            fidl::decode!(
                AssociateResultCode,
                D,
                &mut self.result_code,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(u16, D, &mut self.association_id, decoder, offset + 12, _depth)?;
            fidl::decode!(u16, D, &mut self.capability_info, decoder, offset + 14, _depth)?;
            fidl::decode!(fidl::encoding::Vector<u8, 14>, D, &mut self.rates, decoder, offset + 16, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for AuthenticateIndication {
        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<AuthenticateIndication, D> for &AuthenticateIndication
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AuthenticateIndication>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AuthenticateIndication, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.peer_sta_address,
                    ),
                    <AuthenticationTypes as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.auth_type,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<AuthenticationTypes, D>,
    > fidl::encoding::Encode<AuthenticateIndication, 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::<AuthenticateIndication>(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(4);
                (ptr as *mut u32).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for AuthenticateIndication
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                auth_type: fidl::new_empty!(AuthenticationTypes, 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(4) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let mask = 0xffff0000u32;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
            fidl::decode!(
                AuthenticationTypes,
                D,
                &mut self.auth_type,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for AuthenticateResponse {
        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<AuthenticateResponse, D>
        for &AuthenticateResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AuthenticateResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AuthenticateResponse, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.peer_sta_address,
                    ),
                    <AuthenticateResultCode as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.result_code,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<AuthenticateResultCode, D>,
    > fidl::encoding::Encode<AuthenticateResponse, 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::<AuthenticateResponse>(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(4);
                (ptr as *mut u32).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AuthenticateResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                result_code: fidl::new_empty!(AuthenticateResultCode, 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(4) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let mask = 0xffff0000u32;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
            fidl::decode!(
                AuthenticateResultCode,
                D,
                &mut self.result_code,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BandCapability, D>
        for &BandCapability
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BandCapability>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BandCapability, D>::encode(
                (
                    <fidl_fuchsia_wlan_ieee80211__common::WlanBand as fidl::encoding::ValueTypeMarker>::borrow(&self.band),
                    <fidl::encoding::Vector<u8, 12> as fidl::encoding::ValueTypeMarker>::borrow(&self.basic_rates),
                    <fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities> as fidl::encoding::ValueTypeMarker>::borrow(&self.ht_cap),
                    <fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities> as fidl::encoding::ValueTypeMarker>::borrow(&self.vht_cap),
                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.operating_channels),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::WlanBand, D>,
        T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 12>, D>,
        T2: fidl::encoding::Encode<
                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>,
                D,
            >,
        T3: fidl::encoding::Encode<
                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>,
                D,
            >,
        T4: fidl::encoding::Encode<fidl::encoding::Vector<u8, 256>, D>,
    > fidl::encoding::Encode<BandCapability, D> for (T0, T1, T2, T3, T4)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BandCapability>(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 u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            self.3.encode(encoder, offset + 32, depth)?;
            self.4.encode(encoder, offset + 40, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BandCapability {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                band: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::WlanBand, D),
                basic_rates: fidl::new_empty!(fidl::encoding::Vector<u8, 12>, D),
                ht_cap: fidl::new_empty!(
                    fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>,
                    D
                ),
                vht_cap: fidl::new_empty!(
                    fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>,
                    D
                ),
                operating_channels: fidl::new_empty!(fidl::encoding::Vector<u8, 256>, 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 u64).read_unaligned() };
            let mask = 0xffffffffffffff00u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl_fuchsia_wlan_ieee80211__common::WlanBand,
                D,
                &mut self.band,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::Vector<u8, 12>, D, &mut self.basic_rates, decoder, offset + 8, _depth)?;
            fidl::decode!(
                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>,
                D,
                &mut self.ht_cap,
                decoder,
                offset + 24,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>,
                D,
                &mut self.vht_cap,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(fidl::encoding::Vector<u8, 256>, D, &mut self.operating_channels, decoder, offset + 40, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for CapturedFrameResult {
        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<CapturedFrameResult, D>
        for &CapturedFrameResult
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CapturedFrameResult>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CapturedFrameResult, D>::encode(
                (<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.frame,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
    > fidl::encoding::Encode<CapturedFrameResult, 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::<CapturedFrameResult>(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 CapturedFrameResult {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { frame: fidl::new_empty!(fidl::encoding::UnboundedVector<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.
            fidl::decode!(
                fidl::encoding::UnboundedVector<u8>,
                D,
                &mut self.frame,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConnectConfirm, D>
        for &ConnectConfirm
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ConnectConfirm>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ConnectConfirm, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
                    <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow(&self.result_code),
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.association_id),
                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.association_ies),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>,
        T2: fidl::encoding::Encode<u16, D>,
        T3: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
    > fidl::encoding::Encode<ConnectConfirm, D> for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ConnectConfirm>(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(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 6, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectConfirm {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                result_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D),
                association_id: fidl::new_empty!(u16, D),
                association_ies: fidl::new_empty!(fidl::encoding::UnboundedVector<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(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffffffff0000u64;
            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!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_wlan_ieee80211__common::StatusCode,
                D,
                &mut self.result_code,
                decoder,
                offset + 6,
                _depth
            )?;
            fidl::decode!(u16, D, &mut self.association_id, decoder, offset + 8, _depth)?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<u8>,
                D,
                &mut self.association_ies,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConnectRequest, D>
        for &ConnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ConnectRequest, D>::encode(
                (
                    <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow(&self.selected_bss),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.connect_failure_timeout),
                    <AuthenticationTypes as fidl::encoding::ValueTypeMarker>::borrow(&self.auth_type),
                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.sae_password),
                    <fidl::encoding::Boxed<SetKeyDescriptor> as fidl::encoding::ValueTypeMarker>::borrow(&self.wep_key),
                    <fidl::encoding::Vector<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow(&self.security_ie),
                    <fidl::encoding::Boxed<fidl_fuchsia_wlan_internal__common::OwePublicKey> as fidl::encoding::ValueTypeMarker>::borrow(&self.owe_public_key),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::BssDescription, D>,
        T1: fidl::encoding::Encode<u32, D>,
        T2: fidl::encoding::Encode<AuthenticationTypes, D>,
        T3: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
        T4: fidl::encoding::Encode<fidl::encoding::Boxed<SetKeyDescriptor>, D>,
        T5: fidl::encoding::Encode<fidl::encoding::Vector<u8, 257>, D>,
        T6: fidl::encoding::Encode<
                fidl::encoding::Boxed<fidl_fuchsia_wlan_internal__common::OwePublicKey>,
                D,
            >,
    > fidl::encoding::Encode<ConnectRequest, D> for (T0, T1, T2, T3, T4, T5, T6)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ConnectRequest>(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 + 48, depth)?;
            self.2.encode(encoder, offset + 52, depth)?;
            self.3.encode(encoder, offset + 56, depth)?;
            self.4.encode(encoder, offset + 72, depth)?;
            self.5.encode(encoder, offset + 80, depth)?;
            self.6.encode(encoder, offset + 96, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                selected_bss: fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D),
                connect_failure_timeout: fidl::new_empty!(u32, D),
                auth_type: fidl::new_empty!(AuthenticationTypes, D),
                sae_password: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
                wep_key: fidl::new_empty!(fidl::encoding::Boxed<SetKeyDescriptor>, D),
                security_ie: fidl::new_empty!(fidl::encoding::Vector<u8, 257>, D),
                owe_public_key: fidl::new_empty!(
                    fidl::encoding::Boxed<fidl_fuchsia_wlan_internal__common::OwePublicKey>,
                    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.
            fidl::decode!(
                fidl_fuchsia_wlan_common__common::BssDescription,
                D,
                &mut self.selected_bss,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(u32, D, &mut self.connect_failure_timeout, decoder, offset + 48, _depth)?;
            fidl::decode!(
                AuthenticationTypes,
                D,
                &mut self.auth_type,
                decoder,
                offset + 52,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<u8>,
                D,
                &mut self.sae_password,
                decoder,
                offset + 56,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Boxed<SetKeyDescriptor>,
                D,
                &mut self.wep_key,
                decoder,
                offset + 72,
                _depth
            )?;
            fidl::decode!(fidl::encoding::Vector<u8, 257>, D, &mut self.security_ie, decoder, offset + 80, _depth)?;
            fidl::decode!(
                fidl::encoding::Boxed<fidl_fuchsia_wlan_internal__common::OwePublicKey>,
                D,
                &mut self.owe_public_key,
                decoder,
                offset + 96,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            3
        }
        #[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<Country, D> for &Country {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Country>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Country).write_unaligned((self as *const Country).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, 2>, D>,
        T1: fidl::encoding::Encode<u8, D>,
    > fidl::encoding::Encode<Country, 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::<Country>(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 + 2, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Country {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                alpha2: fidl::new_empty!(fidl::encoding::Array<u8, 2>, D),
                suffix: 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);
            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, 3);
            }
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            6
        }
        #[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<DeauthenticateConfirm, D>
        for &DeauthenticateConfirm
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeauthenticateConfirm>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut DeauthenticateConfirm)
                    .write_unaligned((self as *const DeauthenticateConfirm).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, 6>, D>,
    > fidl::encoding::Encode<DeauthenticateConfirm, 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::<DeauthenticateConfirm>(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 DeauthenticateConfirm {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, 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, 6);
            }
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<DeauthenticateIndication, D> for &DeauthenticateIndication
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeauthenticateIndication>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeauthenticateIndication, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
                    <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow(&self.reason_code),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.locally_initiated),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>,
        T2: fidl::encoding::Encode<bool, D>,
    > fidl::encoding::Encode<DeauthenticateIndication, 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::<DeauthenticateIndication>(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(8);
                (ptr as *mut u16).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 6, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for DeauthenticateIndication
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                reason_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D),
                locally_initiated: fidl::new_empty!(bool, 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(8) };
            let padval = unsafe { (ptr as *const u16).read_unaligned() };
            let mask = 0xff00u16;
            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!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
                D,
                &mut self.reason_code,
                decoder,
                offset + 6,
                _depth
            )?;
            fidl::decode!(bool, D, &mut self.locally_initiated, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeauthenticateRequest, D>
        for &DeauthenticateRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeauthenticateRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeauthenticateRequest, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
                    <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow(&self.reason_code),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>,
    > fidl::encoding::Encode<DeauthenticateRequest, 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::<DeauthenticateRequest>(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 + 6, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeauthenticateRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                reason_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, 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.
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
                D,
                &mut self.reason_code,
                decoder,
                offset + 6,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeleteKeyDescriptor, D>
        for &DeleteKeyDescriptor
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeleteKeyDescriptor>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeleteKeyDescriptor, D>::encode(
                (
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.key_id),
                    <KeyType as fidl::encoding::ValueTypeMarker>::borrow(&self.key_type),
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.address,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<u16, D>,
        T1: fidl::encoding::Encode<KeyType, D>,
        T2: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
    > fidl::encoding::Encode<DeleteKeyDescriptor, 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::<DeleteKeyDescriptor>(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(12);
                (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 DeleteKeyDescriptor {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                key_id: fidl::new_empty!(u16, D),
                key_type: fidl::new_empty!(KeyType, D),
                address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, 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 = 0xffff0000u32;
            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(12) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let mask = 0xffff0000u32;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 12 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(u16, D, &mut self.key_id, decoder, offset + 0, _depth)?;
            fidl::decode!(KeyType, D, &mut self.key_type, decoder, offset + 4, _depth)?;
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.address, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for DeleteKeysRequest {
        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<DeleteKeysRequest, D>
        for &DeleteKeysRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeleteKeysRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeleteKeysRequest, D>::encode(
                (
                    <fidl::encoding::UnboundedVector<DeleteKeyDescriptor> as fidl::encoding::ValueTypeMarker>::borrow(&self.keylist),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<DeleteKeyDescriptor>, D>,
    > fidl::encoding::Encode<DeleteKeysRequest, 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::<DeleteKeysRequest>(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 DeleteKeysRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                keylist: fidl::new_empty!(fidl::encoding::UnboundedVector<DeleteKeyDescriptor>, 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.
            fidl::decode!(
                fidl::encoding::UnboundedVector<DeleteKeyDescriptor>,
                D,
                &mut self.keylist,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceInfo, D>
        for &DeviceInfo
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceInfo>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceInfo, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.sta_addr),
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.factory_addr),
                    <fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::ValueTypeMarker>::borrow(&self.role),
                    <fidl::encoding::Vector<BandCapability, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.bands),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.softmac_hardware_capability),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.qos_capable),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T2: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::WlanMacRole, D>,
        T3: fidl::encoding::Encode<fidl::encoding::Vector<BandCapability, 16>, D>,
        T4: fidl::encoding::Encode<u32, D>,
        T5: fidl::encoding::Encode<bool, D>,
    > fidl::encoding::Encode<DeviceInfo, D> for (T0, T1, T2, T3, T4, T5)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceInfo>(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(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 6, depth)?;
            self.2.encode(encoder, offset + 12, depth)?;
            self.3.encode(encoder, offset + 16, depth)?;
            self.4.encode(encoder, offset + 32, depth)?;
            self.5.encode(encoder, offset + 36, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceInfo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                sta_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                factory_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                role: fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanMacRole, D),
                bands: fidl::new_empty!(fidl::encoding::Vector<BandCapability, 16>, D),
                softmac_hardware_capability: fidl::new_empty!(u32, D),
                qos_capable: fidl::new_empty!(bool, 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(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffff0000000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.sta_addr, decoder, offset + 0, _depth)?;
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.factory_addr, decoder, offset + 6, _depth)?;
            fidl::decode!(
                fidl_fuchsia_wlan_common__common::WlanMacRole,
                D,
                &mut self.role,
                decoder,
                offset + 12,
                _depth
            )?;
            fidl::decode!(fidl::encoding::Vector<BandCapability, 16>, D, &mut self.bands, decoder, offset + 16, _depth)?;
            fidl::decode!(
                u32,
                D,
                &mut self.softmac_hardware_capability,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(bool, D, &mut self.qos_capable, decoder, offset + 36, _depth)?;
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
        #[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<DisassociateConfirm, D>
        for &DisassociateConfirm
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DisassociateConfirm>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut DisassociateConfirm)
                    .write_unaligned((self as *const DisassociateConfirm).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<i32, D>>
        fidl::encoding::Encode<DisassociateConfirm, 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::<DisassociateConfirm>(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 DisassociateConfirm {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { status: fidl::new_empty!(i32, 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, 4);
            }
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<DisassociateIndication, D> for &DisassociateIndication
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DisassociateIndication>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DisassociateIndication, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
                    <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow(&self.reason_code),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.locally_initiated),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>,
        T2: fidl::encoding::Encode<bool, D>,
    > fidl::encoding::Encode<DisassociateIndication, 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::<DisassociateIndication>(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(8);
                (ptr as *mut u16).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 6, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for DisassociateIndication
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                reason_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D),
                locally_initiated: fidl::new_empty!(bool, 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(8) };
            let padval = unsafe { (ptr as *const u16).read_unaligned() };
            let mask = 0xff00u16;
            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!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
                D,
                &mut self.reason_code,
                decoder,
                offset + 6,
                _depth
            )?;
            fidl::decode!(bool, D, &mut self.locally_initiated, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DisassociateRequest, D>
        for &DisassociateRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DisassociateRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DisassociateRequest, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
                    <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow(&self.reason_code),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>,
    > fidl::encoding::Encode<DisassociateRequest, 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::<DisassociateRequest>(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 + 6, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DisassociateRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                reason_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, 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.
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
                D,
                &mut self.reason_code,
                decoder,
                offset + 6,
                _depth
            )?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for EapolConfirm {
        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<EapolConfirm, D>
        for &EapolConfirm
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EapolConfirm>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<EapolConfirm, D>::encode(
                (
                    <EapolResultCode as fidl::encoding::ValueTypeMarker>::borrow(&self.result_code),
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.dst_addr,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<EapolResultCode, D>,
        T1: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
    > fidl::encoding::Encode<EapolConfirm, 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::<EapolConfirm>(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(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EapolConfirm {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                result_code: fidl::new_empty!(EapolResultCode, D),
                dst_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, 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(8) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let mask = 0xffff0000u32;
            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!(EapolResultCode, D, &mut self.result_code, decoder, offset + 0, _depth)?;
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.dst_addr, decoder, offset + 4, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EapolIndication, D>
        for &EapolIndication
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EapolIndication>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<EapolIndication, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.src_addr),
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.dst_addr),
                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T2: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
    > fidl::encoding::Encode<EapolIndication, 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::<EapolIndication>(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(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 6, depth)?;
            self.2.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EapolIndication {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                src_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                dst_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                data: fidl::new_empty!(fidl::encoding::UnboundedVector<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(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            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!(fidl::encoding::Array<u8, 6>, D, &mut self.src_addr, decoder, offset + 0, _depth)?;
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.dst_addr, decoder, offset + 6, _depth)?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<u8>,
                D,
                &mut self.data,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EapolRequest, D>
        for &EapolRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EapolRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<EapolRequest, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.src_addr),
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.dst_addr),
                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T2: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
    > fidl::encoding::Encode<EapolRequest, 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::<EapolRequest>(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(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 6, depth)?;
            self.2.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EapolRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                src_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                dst_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                data: fidl::new_empty!(fidl::encoding::UnboundedVector<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(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            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!(fidl::encoding::Array<u8, 6>, D, &mut self.src_addr, decoder, offset + 0, _depth)?;
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.dst_addr, decoder, offset + 6, _depth)?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<u8>,
                D,
                &mut self.data,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MlmeGetSignalReportResponse {
        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<MlmeGetSignalReportResponse, D> for &MlmeGetSignalReportResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeGetSignalReportResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeGetSignalReportResponse, D>::encode(
                (
                    <fidl_fuchsia_wlan_stats__common::SignalReport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::SignalReport, D>,
    > fidl::encoding::Encode<MlmeGetSignalReportResponse, 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::<MlmeGetSignalReportResponse>(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 MlmeGetSignalReportResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::SignalReport, 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.
            fidl::decode!(
                fidl_fuchsia_wlan_stats__common::SignalReport,
                D,
                &mut self.resp,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MlmeQueryTelemetrySupportResponse {
        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<MlmeQueryTelemetrySupportResponse, D>
        for &MlmeQueryTelemetrySupportResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeQueryTelemetrySupportResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeQueryTelemetrySupportResponse, D>::encode(
                (
                    <fidl_fuchsia_wlan_stats__common::TelemetrySupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::TelemetrySupport, D>,
    > fidl::encoding::Encode<MlmeQueryTelemetrySupportResponse, 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::<MlmeQueryTelemetrySupportResponse>(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 MlmeQueryTelemetrySupportResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::TelemetrySupport, 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.
            fidl::decode!(
                fidl_fuchsia_wlan_stats__common::TelemetrySupport,
                D,
                &mut self.resp,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MinstrelListResponse {
        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<MinstrelListResponse, D>
        for &MinstrelListResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MinstrelListResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MinstrelListResponse, D>::encode(
                (
                    <fidl_fuchsia_wlan_minstrel__common::Peers as fidl::encoding::ValueTypeMarker>::borrow(&self.peers),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_minstrel__common::Peers, D>,
    > fidl::encoding::Encode<MinstrelListResponse, 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::<MinstrelListResponse>(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 MinstrelListResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { peers: fidl::new_empty!(fidl_fuchsia_wlan_minstrel__common::Peers, 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.
            fidl::decode!(
                fidl_fuchsia_wlan_minstrel__common::Peers,
                D,
                &mut self.peers,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            6
        }
        #[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<MinstrelStatsRequest, D>
        for &MinstrelStatsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MinstrelStatsRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut MinstrelStatsRequest)
                    .write_unaligned((self as *const MinstrelStatsRequest).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, 6>, D>,
    > fidl::encoding::Encode<MinstrelStatsRequest, 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::<MinstrelStatsRequest>(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 MinstrelStatsRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { peer_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, 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, 6);
            }
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MinstrelStatsResponse, D>
        for &MinstrelStatsResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MinstrelStatsResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MinstrelStatsResponse, D>::encode(
                (
                    <fidl::encoding::Boxed<fidl_fuchsia_wlan_minstrel__common::Peer> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_wlan_minstrel__common::Peer>, D>,
    > fidl::encoding::Encode<MinstrelStatsResponse, 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::<MinstrelStatsResponse>(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 MinstrelStatsResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer: fidl::new_empty!(
                    fidl::encoding::Boxed<fidl_fuchsia_wlan_minstrel__common::Peer>,
                    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.
            fidl::decode!(
                fidl::encoding::Boxed<fidl_fuchsia_wlan_minstrel__common::Peer>,
                D,
                &mut self.peer,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeAssociateIndRequest, D> for &MlmeAssociateIndRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeAssociateIndRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeAssociateIndRequest, D>::encode(
                (<AssociateIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<AssociateIndication, D>,
    > fidl::encoding::Encode<MlmeAssociateIndRequest, 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::<MlmeAssociateIndRequest>(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 MlmeAssociateIndRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { ind: fidl::new_empty!(AssociateIndication, 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.
            fidl::decode!(AssociateIndication, D, &mut self.ind, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeAssociateRespRequest, D> for &MlmeAssociateRespRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeAssociateRespRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeAssociateRespRequest, D>::encode(
                (<AssociateResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<AssociateResponse, D>,
    > fidl::encoding::Encode<MlmeAssociateRespRequest, 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::<MlmeAssociateRespRequest>(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 MlmeAssociateRespRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(AssociateResponse, 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.
            fidl::decode!(AssociateResponse, D, &mut self.resp, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MlmeAuthenticateIndRequest {
        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<MlmeAuthenticateIndRequest, D> for &MlmeAuthenticateIndRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeAuthenticateIndRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeAuthenticateIndRequest, D>::encode(
                (<AuthenticateIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<AuthenticateIndication, D>,
    > fidl::encoding::Encode<MlmeAuthenticateIndRequest, 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::<MlmeAuthenticateIndRequest>(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 MlmeAuthenticateIndRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { ind: fidl::new_empty!(AuthenticateIndication, 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.
            fidl::decode!(AuthenticateIndication, D, &mut self.ind, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MlmeAuthenticateRespRequest {
        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<MlmeAuthenticateRespRequest, D> for &MlmeAuthenticateRespRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeAuthenticateRespRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeAuthenticateRespRequest, D>::encode(
                (<AuthenticateResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<AuthenticateResponse, D>,
    > fidl::encoding::Encode<MlmeAuthenticateRespRequest, 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::<MlmeAuthenticateRespRequest>(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 MlmeAuthenticateRespRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(AuthenticateResponse, 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.
            fidl::decode!(AuthenticateResponse, D, &mut self.resp, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeConnectConfRequest, D> for &MlmeConnectConfRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeConnectConfRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeConnectConfRequest, D>::encode(
                (<ConnectConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ConnectConfirm, D>>
        fidl::encoding::Encode<MlmeConnectConfRequest, 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::<MlmeConnectConfRequest>(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 MlmeConnectConfRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(ConnectConfirm, 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.
            fidl::decode!(ConnectConfirm, D, &mut self.resp, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeConnectReqRequest, D>
        for &MlmeConnectReqRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeConnectReqRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeConnectReqRequest, D>::encode(
                (<ConnectRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ConnectRequest, D>>
        fidl::encoding::Encode<MlmeConnectReqRequest, 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::<MlmeConnectReqRequest>(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 MlmeConnectReqRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { req: fidl::new_empty!(ConnectRequest, 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.
            fidl::decode!(ConnectRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            6
        }
        #[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<MlmeDeauthenticateConfRequest, D>
        for &MlmeDeauthenticateConfRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeDeauthenticateConfRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut MlmeDeauthenticateConfRequest)
                    .write_unaligned((self as *const MlmeDeauthenticateConfRequest).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<DeauthenticateConfirm, D>,
    > fidl::encoding::Encode<MlmeDeauthenticateConfRequest, 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::<MlmeDeauthenticateConfRequest>(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 MlmeDeauthenticateConfRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(DeauthenticateConfirm, 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, 6);
            }
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeDeauthenticateIndRequest, D> for &MlmeDeauthenticateIndRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeDeauthenticateIndRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeDeauthenticateIndRequest, D>::encode(
                (<DeauthenticateIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<DeauthenticateIndication, D>,
    > fidl::encoding::Encode<MlmeDeauthenticateIndRequest, 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::<MlmeDeauthenticateIndRequest>(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 MlmeDeauthenticateIndRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { ind: fidl::new_empty!(DeauthenticateIndication, 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.
            fidl::decode!(DeauthenticateIndication, D, &mut self.ind, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeDeauthenticateReqRequest, D> for &MlmeDeauthenticateReqRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeDeauthenticateReqRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeDeauthenticateReqRequest, D>::encode(
                (<DeauthenticateRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<DeauthenticateRequest, D>,
    > fidl::encoding::Encode<MlmeDeauthenticateReqRequest, 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::<MlmeDeauthenticateReqRequest>(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 MlmeDeauthenticateReqRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { req: fidl::new_empty!(DeauthenticateRequest, 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.
            fidl::decode!(DeauthenticateRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MlmeDeleteKeysReqRequest {
        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<MlmeDeleteKeysReqRequest, D> for &MlmeDeleteKeysReqRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeDeleteKeysReqRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeDeleteKeysReqRequest, D>::encode(
                (<DeleteKeysRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<DeleteKeysRequest, D>,
    > fidl::encoding::Encode<MlmeDeleteKeysReqRequest, 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::<MlmeDeleteKeysReqRequest>(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 MlmeDeleteKeysReqRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { req: fidl::new_empty!(DeleteKeysRequest, 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.
            fidl::decode!(DeleteKeysRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
        #[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<MlmeDisassociateConfRequest, D> for &MlmeDisassociateConfRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeDisassociateConfRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut MlmeDisassociateConfRequest)
                    .write_unaligned((self as *const MlmeDisassociateConfRequest).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<DisassociateConfirm, D>,
    > fidl::encoding::Encode<MlmeDisassociateConfRequest, 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::<MlmeDisassociateConfRequest>(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 MlmeDisassociateConfRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(DisassociateConfirm, 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, 4);
            }
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeDisassociateIndRequest, D> for &MlmeDisassociateIndRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeDisassociateIndRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeDisassociateIndRequest, D>::encode(
                (<DisassociateIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<DisassociateIndication, D>,
    > fidl::encoding::Encode<MlmeDisassociateIndRequest, 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::<MlmeDisassociateIndRequest>(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 MlmeDisassociateIndRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { ind: fidl::new_empty!(DisassociateIndication, 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.
            fidl::decode!(DisassociateIndication, D, &mut self.ind, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeDisassociateReqRequest, D> for &MlmeDisassociateReqRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeDisassociateReqRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeDisassociateReqRequest, D>::encode(
                (<DisassociateRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<DisassociateRequest, D>,
    > fidl::encoding::Encode<MlmeDisassociateReqRequest, 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::<MlmeDisassociateReqRequest>(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 MlmeDisassociateReqRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { req: fidl::new_empty!(DisassociateRequest, 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.
            fidl::decode!(DisassociateRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MlmeEapolConfRequest {
        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<MlmeEapolConfRequest, D>
        for &MlmeEapolConfRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeEapolConfRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeEapolConfRequest, D>::encode(
                (<EapolConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<EapolConfirm, D>>
        fidl::encoding::Encode<MlmeEapolConfRequest, 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::<MlmeEapolConfRequest>(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 MlmeEapolConfRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(EapolConfirm, 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.
            fidl::decode!(EapolConfirm, D, &mut self.resp, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeEapolIndRequest, D>
        for &MlmeEapolIndRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeEapolIndRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeEapolIndRequest, D>::encode(
                (<EapolIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<EapolIndication, D>>
        fidl::encoding::Encode<MlmeEapolIndRequest, 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::<MlmeEapolIndRequest>(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 MlmeEapolIndRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { ind: fidl::new_empty!(EapolIndication, 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.
            fidl::decode!(EapolIndication, D, &mut self.ind, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeEapolReqRequest, D>
        for &MlmeEapolReqRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeEapolReqRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeEapolReqRequest, D>::encode(
                (<EapolRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<EapolRequest, D>>
        fidl::encoding::Encode<MlmeEapolReqRequest, 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::<MlmeEapolReqRequest>(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 MlmeEapolReqRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { req: fidl::new_empty!(EapolRequest, 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.
            fidl::decode!(EapolRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeFinalizeAssociationReqRequest, D>
        for &MlmeFinalizeAssociationReqRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeFinalizeAssociationReqRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeFinalizeAssociationReqRequest, D>::encode(
                (<NegotiatedCapabilities as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.negotiated_capabilities,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<NegotiatedCapabilities, D>,
    > fidl::encoding::Encode<MlmeFinalizeAssociationReqRequest, 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::<MlmeFinalizeAssociationReqRequest>(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 MlmeFinalizeAssociationReqRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { negotiated_capabilities: fidl::new_empty!(NegotiatedCapabilities, 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.
            fidl::decode!(
                NegotiatedCapabilities,
                D,
                &mut self.negotiated_capabilities,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MlmeGetIfaceHistogramStatsResponse {
        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<MlmeGetIfaceHistogramStatsResponse, D>
        for &MlmeGetIfaceHistogramStatsResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeGetIfaceHistogramStatsResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeGetIfaceHistogramStatsResponse, D>::encode(
                (<GetIfaceHistogramStatsResponse as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.resp,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<GetIfaceHistogramStatsResponse, D>,
    > fidl::encoding::Encode<MlmeGetIfaceHistogramStatsResponse, 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::<MlmeGetIfaceHistogramStatsResponse>(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 MlmeGetIfaceHistogramStatsResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(GetIfaceHistogramStatsResponse, 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.
            fidl::decode!(
                GetIfaceHistogramStatsResponse,
                D,
                &mut self.resp,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MlmeGetIfaceStatsResponse {
        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<MlmeGetIfaceStatsResponse, D> for &MlmeGetIfaceStatsResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeGetIfaceStatsResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeGetIfaceStatsResponse, D>::encode(
                (<GetIfaceStatsResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<GetIfaceStatsResponse, D>,
    > fidl::encoding::Encode<MlmeGetIfaceStatsResponse, 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::<MlmeGetIfaceStatsResponse>(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 MlmeGetIfaceStatsResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(GetIfaceStatsResponse, 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.
            fidl::decode!(GetIfaceStatsResponse, D, &mut self.resp, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            6
        }
        #[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<MlmeGetMinstrelStatsRequest, D> for &MlmeGetMinstrelStatsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeGetMinstrelStatsRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut MlmeGetMinstrelStatsRequest)
                    .write_unaligned((self as *const MlmeGetMinstrelStatsRequest).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<MinstrelStatsRequest, D>,
    > fidl::encoding::Encode<MlmeGetMinstrelStatsRequest, 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::<MlmeGetMinstrelStatsRequest>(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 MlmeGetMinstrelStatsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { req: fidl::new_empty!(MinstrelStatsRequest, 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, 6);
            }
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeGetMinstrelStatsResponse, D> for &MlmeGetMinstrelStatsResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeGetMinstrelStatsResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeGetMinstrelStatsResponse, D>::encode(
                (<MinstrelStatsResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<MinstrelStatsResponse, D>,
    > fidl::encoding::Encode<MlmeGetMinstrelStatsResponse, 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::<MlmeGetMinstrelStatsResponse>(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 MlmeGetMinstrelStatsResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(MinstrelStatsResponse, 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.
            fidl::decode!(MinstrelStatsResponse, D, &mut self.resp, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MlmeListMinstrelPeersResponse {
        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<MlmeListMinstrelPeersResponse, D>
        for &MlmeListMinstrelPeersResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeListMinstrelPeersResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeListMinstrelPeersResponse, D>::encode(
                (<MinstrelListResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<MinstrelListResponse, D>,
    > fidl::encoding::Encode<MlmeListMinstrelPeersResponse, 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::<MlmeListMinstrelPeersResponse>(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 MlmeListMinstrelPeersResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(MinstrelListResponse, 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.
            fidl::decode!(MinstrelListResponse, D, &mut self.resp, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeOnChannelSwitchedRequest, D> for &MlmeOnChannelSwitchedRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeOnChannelSwitchedRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeOnChannelSwitchedRequest, D>::encode(
                (
                    <fidl_fuchsia_wlan_internal__common::ChannelSwitchInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_internal__common::ChannelSwitchInfo, D>,
    > fidl::encoding::Encode<MlmeOnChannelSwitchedRequest, 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::<MlmeOnChannelSwitchedRequest>(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 MlmeOnChannelSwitchedRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                info: fidl::new_empty!(fidl_fuchsia_wlan_internal__common::ChannelSwitchInfo, 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.
            fidl::decode!(
                fidl_fuchsia_wlan_internal__common::ChannelSwitchInfo,
                D,
                &mut self.info,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeOnPmkAvailableRequest, D> for &MlmeOnPmkAvailableRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeOnPmkAvailableRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeOnPmkAvailableRequest, D>::encode(
                (<PmkInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PmkInfo, D>>
        fidl::encoding::Encode<MlmeOnPmkAvailableRequest, 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::<MlmeOnPmkAvailableRequest>(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 MlmeOnPmkAvailableRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { info: fidl::new_empty!(PmkInfo, 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.
            fidl::decode!(PmkInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeOnSaeFrameRxRequest, D> for &MlmeOnSaeFrameRxRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeOnSaeFrameRxRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeOnSaeFrameRxRequest, D>::encode(
                (<SaeFrame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SaeFrame, D>>
        fidl::encoding::Encode<MlmeOnSaeFrameRxRequest, 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::<MlmeOnSaeFrameRxRequest>(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 MlmeOnSaeFrameRxRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { frame: fidl::new_empty!(SaeFrame, 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.
            fidl::decode!(SaeFrame, D, &mut self.frame, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            6
        }
        #[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<MlmeOnSaeHandshakeIndRequest, D> for &MlmeOnSaeHandshakeIndRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeOnSaeHandshakeIndRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut MlmeOnSaeHandshakeIndRequest)
                    .write_unaligned((self as *const MlmeOnSaeHandshakeIndRequest).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<SaeHandshakeIndication, D>,
    > fidl::encoding::Encode<MlmeOnSaeHandshakeIndRequest, 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::<MlmeOnSaeHandshakeIndRequest>(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 MlmeOnSaeHandshakeIndRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { ind: fidl::new_empty!(SaeHandshakeIndication, 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, 6);
            }
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MlmeOnScanEndRequest {
        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<MlmeOnScanEndRequest, D>
        for &MlmeOnScanEndRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeOnScanEndRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeOnScanEndRequest, D>::encode(
                (<ScanEnd as fidl::encoding::ValueTypeMarker>::borrow(&self.end),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ScanEnd, D>>
        fidl::encoding::Encode<MlmeOnScanEndRequest, 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::<MlmeOnScanEndRequest>(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 MlmeOnScanEndRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { end: fidl::new_empty!(ScanEnd, 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.
            fidl::decode!(ScanEnd, D, &mut self.end, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeOnScanResultRequest, D> for &MlmeOnScanResultRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeOnScanResultRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeOnScanResultRequest, D>::encode(
                (<ScanResult as fidl::encoding::ValueTypeMarker>::borrow(&self.result),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ScanResult, D>>
        fidl::encoding::Encode<MlmeOnScanResultRequest, 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::<MlmeOnScanResultRequest>(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 MlmeOnScanResultRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { result: fidl::new_empty!(ScanResult, 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.
            fidl::decode!(ScanResult, D, &mut self.result, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeOnWmmStatusRespRequest, D> for &MlmeOnWmmStatusRespRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeOnWmmStatusRespRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeOnWmmStatusRespRequest, D>::encode(
                (
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
                    <fidl_fuchsia_wlan_internal__common::WmmStatusResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<i32, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_internal__common::WmmStatusResponse, D>,
    > fidl::encoding::Encode<MlmeOnWmmStatusRespRequest, 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::<MlmeOnWmmStatusRespRequest>(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(36);
                (ptr as *mut u32).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for MlmeOnWmmStatusRespRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                status: fidl::new_empty!(i32, D),
                resp: fidl::new_empty!(fidl_fuchsia_wlan_internal__common::WmmStatusResponse, 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(36) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let mask = 0xffff0000u32;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 36 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(i32, D, &mut self.status, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_wlan_internal__common::WmmStatusResponse,
                D,
                &mut self.resp,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeQueryDeviceInfoResponse, D> for &MlmeQueryDeviceInfoResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeQueryDeviceInfoResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeQueryDeviceInfoResponse, D>::encode(
                (<DeviceInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<DeviceInfo, D>>
        fidl::encoding::Encode<MlmeQueryDeviceInfoResponse, 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::<MlmeQueryDeviceInfoResponse>(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 MlmeQueryDeviceInfoResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { info: fidl::new_empty!(DeviceInfo, 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.
            fidl::decode!(DeviceInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            6
        }
        #[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<MlmeReconnectReqRequest, D> for &MlmeReconnectReqRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeReconnectReqRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut MlmeReconnectReqRequest)
                    .write_unaligned((self as *const MlmeReconnectReqRequest).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<ReconnectRequest, D>>
        fidl::encoding::Encode<MlmeReconnectReqRequest, 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::<MlmeReconnectReqRequest>(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 MlmeReconnectReqRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { req: fidl::new_empty!(ReconnectRequest, 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, 6);
            }
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MlmeRelayCapturedFrameRequest {
        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<MlmeRelayCapturedFrameRequest, D>
        for &MlmeRelayCapturedFrameRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeRelayCapturedFrameRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeRelayCapturedFrameRequest, D>::encode(
                (<CapturedFrameResult as fidl::encoding::ValueTypeMarker>::borrow(&self.result),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<CapturedFrameResult, D>,
    > fidl::encoding::Encode<MlmeRelayCapturedFrameRequest, 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::<MlmeRelayCapturedFrameRequest>(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 MlmeRelayCapturedFrameRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { result: fidl::new_empty!(CapturedFrameResult, 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.
            fidl::decode!(CapturedFrameResult, D, &mut self.result, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeResetReqRequest, D>
        for &MlmeResetReqRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeResetReqRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeResetReqRequest, D>::encode(
                (<ResetRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ResetRequest, D>>
        fidl::encoding::Encode<MlmeResetReqRequest, 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::<MlmeResetReqRequest>(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 MlmeResetReqRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { req: fidl::new_empty!(ResetRequest, 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.
            fidl::decode!(ResetRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeRoamConfRequest, D>
        for &MlmeRoamConfRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeRoamConfRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeRoamConfRequest, D>::encode(
                (<RoamConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.conf),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<RoamConfirm, D>>
        fidl::encoding::Encode<MlmeRoamConfRequest, 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::<MlmeRoamConfRequest>(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 MlmeRoamConfRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { conf: fidl::new_empty!(RoamConfirm, 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.
            fidl::decode!(RoamConfirm, D, &mut self.conf, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeRoamReqRequest, D>
        for &MlmeRoamReqRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeRoamReqRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeRoamReqRequest, D>::encode(
                (<RoamRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<RoamRequest, D>>
        fidl::encoding::Encode<MlmeRoamReqRequest, 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::<MlmeRoamReqRequest>(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 MlmeRoamReqRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { req: fidl::new_empty!(RoamRequest, 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.
            fidl::decode!(RoamRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeRoamResultIndRequest, D> for &MlmeRoamResultIndRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeRoamResultIndRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeRoamResultIndRequest, D>::encode(
                (<RoamResultIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<RoamResultIndication, D>,
    > fidl::encoding::Encode<MlmeRoamResultIndRequest, 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::<MlmeRoamResultIndRequest>(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 MlmeRoamResultIndRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { ind: fidl::new_empty!(RoamResultIndication, 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.
            fidl::decode!(RoamResultIndication, D, &mut self.ind, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeRoamStartIndRequest, D> for &MlmeRoamStartIndRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeRoamStartIndRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeRoamStartIndRequest, D>::encode(
                (<RoamStartIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<RoamStartIndication, D>,
    > fidl::encoding::Encode<MlmeRoamStartIndRequest, 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::<MlmeRoamStartIndRequest>(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 MlmeRoamStartIndRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { ind: fidl::new_empty!(RoamStartIndication, 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.
            fidl::decode!(RoamStartIndication, D, &mut self.ind, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeSaeFrameTxRequest, D>
        for &MlmeSaeFrameTxRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeSaeFrameTxRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeSaeFrameTxRequest, D>::encode(
                (<SaeFrame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SaeFrame, D>>
        fidl::encoding::Encode<MlmeSaeFrameTxRequest, 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::<MlmeSaeFrameTxRequest>(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 MlmeSaeFrameTxRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { frame: fidl::new_empty!(SaeFrame, 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.
            fidl::decode!(SaeFrame, D, &mut self.frame, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeSaeHandshakeRespRequest, D> for &MlmeSaeHandshakeRespRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeSaeHandshakeRespRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeSaeHandshakeRespRequest, D>::encode(
                (<SaeHandshakeResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<SaeHandshakeResponse, D>,
    > fidl::encoding::Encode<MlmeSaeHandshakeRespRequest, 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::<MlmeSaeHandshakeRespRequest>(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 MlmeSaeHandshakeRespRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(SaeHandshakeResponse, 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.
            fidl::decode!(SaeHandshakeResponse, D, &mut self.resp, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MlmeSetControlledPortRequest {
        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<MlmeSetControlledPortRequest, D> for &MlmeSetControlledPortRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeSetControlledPortRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeSetControlledPortRequest, D>::encode(
                (<SetControlledPortRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<SetControlledPortRequest, D>,
    > fidl::encoding::Encode<MlmeSetControlledPortRequest, 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::<MlmeSetControlledPortRequest>(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 MlmeSetControlledPortRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { req: fidl::new_empty!(SetControlledPortRequest, 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.
            fidl::decode!(SetControlledPortRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MlmeSetKeysConfRequest {
        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<MlmeSetKeysConfRequest, D> for &MlmeSetKeysConfRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeSetKeysConfRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeSetKeysConfRequest, D>::encode(
                (<SetKeysConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.conf),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SetKeysConfirm, D>>
        fidl::encoding::Encode<MlmeSetKeysConfRequest, 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::<MlmeSetKeysConfRequest>(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 MlmeSetKeysConfRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { conf: fidl::new_empty!(SetKeysConfirm, 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.
            fidl::decode!(SetKeysConfirm, D, &mut self.conf, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MlmeSetKeysReqRequest {
        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<MlmeSetKeysReqRequest, D>
        for &MlmeSetKeysReqRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeSetKeysReqRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeSetKeysReqRequest, D>::encode(
                (<SetKeysRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SetKeysRequest, D>>
        fidl::encoding::Encode<MlmeSetKeysReqRequest, 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::<MlmeSetKeysReqRequest>(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 MlmeSetKeysReqRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { req: fidl::new_empty!(SetKeysRequest, 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.
            fidl::decode!(SetKeysRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            6
        }
        #[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<MlmeSetMacAddressRequest, D> for &MlmeSetMacAddressRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeSetMacAddressRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut MlmeSetMacAddressRequest)
                    .write_unaligned((self as *const MlmeSetMacAddressRequest).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, 6>, D>,
    > fidl::encoding::Encode<MlmeSetMacAddressRequest, 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::<MlmeSetMacAddressRequest>(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 MlmeSetMacAddressRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { mac_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, 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, 6);
            }
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeSignalReportRequest, D> for &MlmeSignalReportRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeSignalReportRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeSignalReportRequest, D>::encode(
                (
                    <fidl_fuchsia_wlan_internal__common::SignalReportIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_internal__common::SignalReportIndication, D>,
    > fidl::encoding::Encode<MlmeSignalReportRequest, 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::<MlmeSignalReportRequest>(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 MlmeSignalReportRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                ind: fidl::new_empty!(
                    fidl_fuchsia_wlan_internal__common::SignalReportIndication,
                    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.
            fidl::decode!(
                fidl_fuchsia_wlan_internal__common::SignalReportIndication,
                D,
                &mut self.ind,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeStartCaptureFramesRequest, D>
        for &MlmeStartCaptureFramesRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeStartCaptureFramesRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeStartCaptureFramesRequest, D>::encode(
                (<StartCaptureFramesRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<StartCaptureFramesRequest, D>,
    > fidl::encoding::Encode<MlmeStartCaptureFramesRequest, 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::<MlmeStartCaptureFramesRequest>(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 MlmeStartCaptureFramesRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { req: fidl::new_empty!(StartCaptureFramesRequest, 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.
            fidl::decode!(
                StartCaptureFramesRequest,
                D,
                &mut self.req,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<MlmeStartCaptureFramesResponse, D>
        for &MlmeStartCaptureFramesResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeStartCaptureFramesResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeStartCaptureFramesResponse, D>::encode(
                (<StartCaptureFramesResponse as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.resp,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<StartCaptureFramesResponse, D>,
    > fidl::encoding::Encode<MlmeStartCaptureFramesResponse, 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::<MlmeStartCaptureFramesResponse>(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 MlmeStartCaptureFramesResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(StartCaptureFramesResponse, 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.
            fidl::decode!(
                StartCaptureFramesResponse,
                D,
                &mut self.resp,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeStartConfRequest, D>
        for &MlmeStartConfRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeStartConfRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeStartConfRequest, D>::encode(
                (<StartConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StartConfirm, D>>
        fidl::encoding::Encode<MlmeStartConfRequest, 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::<MlmeStartConfRequest>(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 MlmeStartConfRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(StartConfirm, 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.
            fidl::decode!(StartConfirm, D, &mut self.resp, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeStartReqRequest, D>
        for &MlmeStartReqRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeStartReqRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeStartReqRequest, D>::encode(
                (<StartRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StartRequest, D>>
        fidl::encoding::Encode<MlmeStartReqRequest, 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::<MlmeStartReqRequest>(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 MlmeStartReqRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { req: fidl::new_empty!(StartRequest, 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.
            fidl::decode!(StartRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeStartScanRequest, D>
        for &MlmeStartScanRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeStartScanRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeStartScanRequest, D>::encode(
                (<ScanRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ScanRequest, D>>
        fidl::encoding::Encode<MlmeStartScanRequest, 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::<MlmeStartScanRequest>(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 MlmeStartScanRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { req: fidl::new_empty!(ScanRequest, 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.
            fidl::decode!(ScanRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeStopConfRequest, D>
        for &MlmeStopConfRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeStopConfRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeStopConfRequest, D>::encode(
                (<StopConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StopConfirm, D>>
        fidl::encoding::Encode<MlmeStopConfRequest, 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::<MlmeStopConfRequest>(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 MlmeStopConfRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resp: fidl::new_empty!(StopConfirm, 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.
            fidl::decode!(StopConfirm, D, &mut self.resp, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for MlmeStopReqRequest {
        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<MlmeStopReqRequest, D>
        for &MlmeStopReqRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MlmeStopReqRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MlmeStopReqRequest, D>::encode(
                (<StopRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StopRequest, D>>
        fidl::encoding::Encode<MlmeStopReqRequest, 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::<MlmeStopReqRequest>(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 MlmeStopReqRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { req: fidl::new_empty!(StopRequest, 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.
            fidl::decode!(StopRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<NegotiatedCapabilities, D> for &NegotiatedCapabilities
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NegotiatedCapabilities>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NegotiatedCapabilities, D>::encode(
                (
                    <fidl_fuchsia_wlan_ieee80211__common::WlanChannel as fidl::encoding::ValueTypeMarker>::borrow(&self.channel),
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.capability_info),
                    <fidl::encoding::Vector<u8, 14> as fidl::encoding::ValueTypeMarker>::borrow(&self.rates),
                    <fidl::encoding::Boxed<WmmParameter> as fidl::encoding::ValueTypeMarker>::borrow(&self.wmm_param),
                    <fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities> as fidl::encoding::ValueTypeMarker>::borrow(&self.ht_cap),
                    <fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities> as fidl::encoding::ValueTypeMarker>::borrow(&self.vht_cap),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::WlanChannel, D>,
        T1: fidl::encoding::Encode<u16, D>,
        T2: fidl::encoding::Encode<fidl::encoding::Vector<u8, 14>, D>,
        T3: fidl::encoding::Encode<fidl::encoding::Boxed<WmmParameter>, D>,
        T4: fidl::encoding::Encode<
                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>,
                D,
            >,
        T5: fidl::encoding::Encode<
                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>,
                D,
            >,
    > fidl::encoding::Encode<NegotiatedCapabilities, D> for (T0, T1, T2, T3, T4, T5)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NegotiatedCapabilities>(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(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 12, depth)?;
            self.2.encode(encoder, offset + 16, depth)?;
            self.3.encode(encoder, offset + 32, depth)?;
            self.4.encode(encoder, offset + 40, depth)?;
            self.5.encode(encoder, offset + 48, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for NegotiatedCapabilities
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                channel: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::WlanChannel, D),
                capability_info: fidl::new_empty!(u16, D),
                rates: fidl::new_empty!(fidl::encoding::Vector<u8, 14>, D),
                wmm_param: fidl::new_empty!(fidl::encoding::Boxed<WmmParameter>, D),
                ht_cap: fidl::new_empty!(
                    fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>,
                    D
                ),
                vht_cap: fidl::new_empty!(
                    fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>,
                    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(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffff000000000000u64;
            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!(
                fidl_fuchsia_wlan_ieee80211__common::WlanChannel,
                D,
                &mut self.channel,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(u16, D, &mut self.capability_info, decoder, offset + 12, _depth)?;
            fidl::decode!(fidl::encoding::Vector<u8, 14>, D, &mut self.rates, decoder, offset + 16, _depth)?;
            fidl::decode!(
                fidl::encoding::Boxed<WmmParameter>,
                D,
                &mut self.wmm_param,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>,
                D,
                &mut self.ht_cap,
                decoder,
                offset + 40,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>,
                D,
                &mut self.vht_cap,
                decoder,
                offset + 48,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PmkInfo, D> for &PmkInfo {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PmkInfo>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PmkInfo, D>::encode(
                (
                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.pmk),
                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.pmkid),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
        T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
    > fidl::encoding::Encode<PmkInfo, 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::<PmkInfo>(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 + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PmkInfo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                pmk: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
                pmkid: fidl::new_empty!(fidl::encoding::UnboundedVector<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.
            fidl::decode!(
                fidl::encoding::UnboundedVector<u8>,
                D,
                &mut self.pmk,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<u8>,
                D,
                &mut self.pmkid,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            6
        }
        #[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<ReconnectRequest, D>
        for &ReconnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ReconnectRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut ReconnectRequest)
                    .write_unaligned((self as *const ReconnectRequest).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, 6>, D>,
    > fidl::encoding::Encode<ReconnectRequest, 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::<ReconnectRequest>(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 ReconnectRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, 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, 6);
            }
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ResetRequest, D>
        for &ResetRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ResetRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ResetRequest, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.sta_address,
                    ),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.set_default_mib),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<bool, D>,
    > fidl::encoding::Encode<ResetRequest, 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::<ResetRequest>(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 + 6, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResetRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                set_default_mib: fidl::new_empty!(bool, 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.
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.sta_address, decoder, offset + 0, _depth)?;
            fidl::decode!(bool, D, &mut self.set_default_mib, decoder, offset + 6, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RoamConfirm, D>
        for &RoamConfirm
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RoamConfirm>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RoamConfirm, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.selected_bssid),
                    <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow(&self.status_code),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.original_association_maintained),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.target_bss_authenticated),
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.association_id),
                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.association_ies),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>,
        T2: fidl::encoding::Encode<bool, D>,
        T3: fidl::encoding::Encode<bool, D>,
        T4: fidl::encoding::Encode<u16, D>,
        T5: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
    > fidl::encoding::Encode<RoamConfirm, D> for (T0, T1, T2, T3, T4, T5)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RoamConfirm>(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(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 6, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 9, depth)?;
            self.4.encode(encoder, offset + 10, depth)?;
            self.5.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RoamConfirm {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                selected_bssid: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                status_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D),
                original_association_maintained: fidl::new_empty!(bool, D),
                target_bss_authenticated: fidl::new_empty!(bool, D),
                association_id: fidl::new_empty!(u16, D),
                association_ies: fidl::new_empty!(fidl::encoding::UnboundedVector<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(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            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!(fidl::encoding::Array<u8, 6>, D, &mut self.selected_bssid, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_wlan_ieee80211__common::StatusCode,
                D,
                &mut self.status_code,
                decoder,
                offset + 6,
                _depth
            )?;
            fidl::decode!(
                bool,
                D,
                &mut self.original_association_maintained,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                bool,
                D,
                &mut self.target_bss_authenticated,
                decoder,
                offset + 9,
                _depth
            )?;
            fidl::decode!(u16, D, &mut self.association_id, decoder, offset + 10, _depth)?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<u8>,
                D,
                &mut self.association_ies,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RoamRequest, D>
        for &RoamRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RoamRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RoamRequest, D>::encode(
                (
                    <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow(&self.selected_bss),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::BssDescription, D>,
    > fidl::encoding::Encode<RoamRequest, 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::<RoamRequest>(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 RoamRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                selected_bss: fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, 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.
            fidl::decode!(
                fidl_fuchsia_wlan_common__common::BssDescription,
                D,
                &mut self.selected_bss,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RoamResultIndication, D>
        for &RoamResultIndication
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RoamResultIndication>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RoamResultIndication, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.selected_bssid),
                    <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow(&self.status_code),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.original_association_maintained),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.target_bss_authenticated),
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.association_id),
                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.association_ies),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>,
        T2: fidl::encoding::Encode<bool, D>,
        T3: fidl::encoding::Encode<bool, D>,
        T4: fidl::encoding::Encode<u16, D>,
        T5: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
    > fidl::encoding::Encode<RoamResultIndication, D> for (T0, T1, T2, T3, T4, T5)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RoamResultIndication>(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(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 6, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 9, depth)?;
            self.4.encode(encoder, offset + 10, depth)?;
            self.5.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RoamResultIndication {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                selected_bssid: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                status_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D),
                original_association_maintained: fidl::new_empty!(bool, D),
                target_bss_authenticated: fidl::new_empty!(bool, D),
                association_id: fidl::new_empty!(u16, D),
                association_ies: fidl::new_empty!(fidl::encoding::UnboundedVector<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(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            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!(fidl::encoding::Array<u8, 6>, D, &mut self.selected_bssid, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_wlan_ieee80211__common::StatusCode,
                D,
                &mut self.status_code,
                decoder,
                offset + 6,
                _depth
            )?;
            fidl::decode!(
                bool,
                D,
                &mut self.original_association_maintained,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                bool,
                D,
                &mut self.target_bss_authenticated,
                decoder,
                offset + 9,
                _depth
            )?;
            fidl::decode!(u16, D, &mut self.association_id, decoder, offset + 10, _depth)?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<u8>,
                D,
                &mut self.association_ies,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RoamStartIndication, D>
        for &RoamStartIndication
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RoamStartIndication>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RoamStartIndication, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.selected_bssid),
                    <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow(&self.selected_bss),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.original_association_maintained),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::BssDescription, D>,
        T2: fidl::encoding::Encode<bool, D>,
    > fidl::encoding::Encode<RoamStartIndication, 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::<RoamStartIndication>(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 u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(56);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 56, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RoamStartIndication {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                selected_bssid: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                selected_bss: fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D),
                original_association_maintained: fidl::new_empty!(bool, 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 u64).read_unaligned() };
            let mask = 0xffff000000000000u64;
            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(56) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffffffffff00u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 56 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.selected_bssid, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_wlan_common__common::BssDescription,
                D,
                &mut self.selected_bss,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                bool,
                D,
                &mut self.original_association_maintained,
                decoder,
                offset + 56,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SaeFrame, D> for &SaeFrame {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SaeFrame>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SaeFrame, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
                    <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow(&self.status_code),
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.seq_num),
                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.sae_fields),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>,
        T2: fidl::encoding::Encode<u16, D>,
        T3: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
    > fidl::encoding::Encode<SaeFrame, D> for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SaeFrame>(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(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 6, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SaeFrame {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                status_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D),
                seq_num: fidl::new_empty!(u16, D),
                sae_fields: fidl::new_empty!(fidl::encoding::UnboundedVector<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(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffffffff0000u64;
            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!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_wlan_ieee80211__common::StatusCode,
                D,
                &mut self.status_code,
                decoder,
                offset + 6,
                _depth
            )?;
            fidl::decode!(u16, D, &mut self.seq_num, decoder, offset + 8, _depth)?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<u8>,
                D,
                &mut self.sae_fields,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            6
        }
        #[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<SaeHandshakeIndication, D> for &SaeHandshakeIndication
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SaeHandshakeIndication>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut SaeHandshakeIndication)
                    .write_unaligned((self as *const SaeHandshakeIndication).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, 6>, D>,
    > fidl::encoding::Encode<SaeHandshakeIndication, 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::<SaeHandshakeIndication>(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 SaeHandshakeIndication
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, 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, 6);
            }
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SaeHandshakeResponse, D>
        for &SaeHandshakeResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SaeHandshakeResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SaeHandshakeResponse, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
                    <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow(&self.status_code),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>,
    > fidl::encoding::Encode<SaeHandshakeResponse, 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::<SaeHandshakeResponse>(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 + 6, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SaeHandshakeResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                status_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, 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.
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_wlan_ieee80211__common::StatusCode,
                D,
                &mut self.status_code,
                decoder,
                offset + 6,
                _depth
            )?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for ScanEnd {
        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<ScanEnd, D> for &ScanEnd {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ScanEnd>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ScanEnd, D>::encode(
                (
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.txn_id),
                    <ScanResultCode as fidl::encoding::ValueTypeMarker>::borrow(&self.code),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<u64, D>,
        T1: fidl::encoding::Encode<ScanResultCode, D>,
    > fidl::encoding::Encode<ScanEnd, 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::<ScanEnd>(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(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanEnd {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { txn_id: fidl::new_empty!(u64, D), code: fidl::new_empty!(ScanResultCode, 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(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            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!(u64, D, &mut self.txn_id, decoder, offset + 0, _depth)?;
            fidl::decode!(ScanResultCode, D, &mut self.code, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanRequest, D>
        for &ScanRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ScanRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ScanRequest, D>::encode(
                (
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.txn_id),
                    <ScanTypes as fidl::encoding::ValueTypeMarker>::borrow(&self.scan_type),
                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.channel_list),
                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>> as fidl::encoding::ValueTypeMarker>::borrow(&self.ssid_list),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.probe_delay),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.min_channel_time),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.max_channel_time),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<u64, D>,
        T1: fidl::encoding::Encode<ScanTypes, D>,
        T2: fidl::encoding::Encode<fidl::encoding::Vector<u8, 256>, D>,
        T3: fidl::encoding::Encode<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>, D>,
        T4: fidl::encoding::Encode<u32, D>,
        T5: fidl::encoding::Encode<u32, D>,
        T6: fidl::encoding::Encode<u32, D>,
    > fidl::encoding::Encode<ScanRequest, D> for (T0, T1, T2, T3, T4, T5, T6)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ScanRequest>(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(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(56);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 16, depth)?;
            self.3.encode(encoder, offset + 32, depth)?;
            self.4.encode(encoder, offset + 48, depth)?;
            self.5.encode(encoder, offset + 52, depth)?;
            self.6.encode(encoder, offset + 56, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                txn_id: fidl::new_empty!(u64, D),
                scan_type: fidl::new_empty!(ScanTypes, D),
                channel_list: fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D),
                ssid_list: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>,
                    D
                ),
                probe_delay: fidl::new_empty!(u32, D),
                min_channel_time: fidl::new_empty!(u32, D),
                max_channel_time: fidl::new_empty!(u32, 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(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(56) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 56 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(u64, D, &mut self.txn_id, decoder, offset + 0, _depth)?;
            fidl::decode!(ScanTypes, D, &mut self.scan_type, decoder, offset + 8, _depth)?;
            fidl::decode!(fidl::encoding::Vector<u8, 256>, D, &mut self.channel_list, decoder, offset + 16, _depth)?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>,
                D,
                &mut self.ssid_list,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(u32, D, &mut self.probe_delay, decoder, offset + 48, _depth)?;
            fidl::decode!(u32, D, &mut self.min_channel_time, decoder, offset + 52, _depth)?;
            fidl::decode!(u32, D, &mut self.max_channel_time, decoder, offset + 56, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanResult, D>
        for &ScanResult
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ScanResult>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ScanResult, D>::encode(
                (
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.txn_id),
                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timestamp_nanos),
                    <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow(&self.bss),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<u64, D>,
        T1: fidl::encoding::Encode<i64, D>,
        T2: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::BssDescription, D>,
    > fidl::encoding::Encode<ScanResult, 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::<ScanResult>(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 + 8, depth)?;
            self.2.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanResult {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                txn_id: fidl::new_empty!(u64, D),
                timestamp_nanos: fidl::new_empty!(i64, D),
                bss: fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, 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.
            fidl::decode!(u64, D, &mut self.txn_id, decoder, offset + 0, _depth)?;
            fidl::decode!(i64, D, &mut self.timestamp_nanos, decoder, offset + 8, _depth)?;
            fidl::decode!(
                fidl_fuchsia_wlan_common__common::BssDescription,
                D,
                &mut self.bss,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for SetControlledPortRequest {
        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<SetControlledPortRequest, D> for &SetControlledPortRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SetControlledPortRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SetControlledPortRequest, D>::encode(
                (
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.peer_sta_address,
                    ),
                    <ControlledPortState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T1: fidl::encoding::Encode<ControlledPortState, D>,
    > fidl::encoding::Encode<SetControlledPortRequest, 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::<SetControlledPortRequest>(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(4);
                (ptr as *mut u32).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for SetControlledPortRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                state: fidl::new_empty!(ControlledPortState, 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(4) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let mask = 0xffff0000u32;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
            fidl::decode!(ControlledPortState, D, &mut self.state, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

    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 {
            48
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SetKeyDescriptor, D>
        for &SetKeyDescriptor
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SetKeyDescriptor>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SetKeyDescriptor, D>::encode(
                (
                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.key_id),
                    <KeyType as fidl::encoding::ValueTypeMarker>::borrow(&self.key_type),
                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.rsc),
                    <fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.cipher_suite_oui),
                    <fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType as fidl::encoding::ValueTypeMarker>::borrow(&self.cipher_suite_type),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
        T1: fidl::encoding::Encode<u16, D>,
        T2: fidl::encoding::Encode<KeyType, D>,
        T3: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
        T4: fidl::encoding::Encode<u64, D>,
        T5: fidl::encoding::Encode<fidl::encoding::Array<u8, 3>, D>,
        T6: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType, D>,
    > fidl::encoding::Encode<SetKeyDescriptor, D> for (T0, T1, T2, T3, T4, T5, T6)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SetKeyDescriptor>(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(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 20, depth)?;
            self.3.encode(encoder, offset + 24, depth)?;
            self.4.encode(encoder, offset + 32, depth)?;
            self.5.encode(encoder, offset + 40, depth)?;
            self.6.encode(encoder, offset + 44, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SetKeyDescriptor {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                key: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
                key_id: fidl::new_empty!(u16, D),
                key_type: fidl::new_empty!(KeyType, D),
                address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
                rsc: fidl::new_empty!(u64, D),
                cipher_suite_oui: fidl::new_empty!(fidl::encoding::Array<u8, 3>, D),
                cipher_suite_type: fidl::new_empty!(
                    fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType,
                    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(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffff0000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffff000000000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xff000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::UnboundedVector<u8>,
                D,
                &mut self.key,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(u16, D, &mut self.key_id, decoder, offset + 16, _depth)?;
            fidl::decode!(KeyType, D, &mut self.key_type, decoder, offset + 20, _depth)?;
            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.address, decoder, offset + 24, _depth)?;
            fidl::decode!(u64, D, &mut self.rsc, decoder, offset + 32, _depth)?;
            fidl::decode!(fidl::encoding::Array<u8, 3>, D, &mut self.cipher_suite_oui, decoder, offset + 40, _depth)?;
            fidl::decode!(
                fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType,
                D,
                &mut self.cipher_suite_type,
                decoder,
                offset + 44,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SetKeyResult, D>
        for &SetKeyResult
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SetKeyResult>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut SetKeyResult)
                    .write_unaligned((self as *const SetKeyResult).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                let padding_ptr = buf_ptr.offset(0) as *mut u32;
                let padding_mask = 0xffff0000u32;
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
            }
            Ok(())
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<u16, D>,
        T1: fidl::encoding::Encode<i32, D>,
    > fidl::encoding::Encode<SetKeyResult, 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::<SetKeyResult>(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);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SetKeyResult {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { key_id: fidl::new_empty!(u16, D), status: fidl::new_empty!(i32, 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.
            let ptr = unsafe { buf_ptr.offset(0) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let mask = 0xffff0000u32;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for SetKeysConfirm {
        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<SetKeysConfirm, D>
        for &SetKeysConfirm
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SetKeysConfirm>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SetKeysConfirm, D>::encode(
                (
                    <fidl::encoding::UnboundedVector<SetKeyResult> as fidl::encoding::ValueTypeMarker>::borrow(&self.results),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<SetKeyResult>, D>,
    > fidl::encoding::Encode<SetKeysConfirm, 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::<SetKeysConfirm>(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 SetKeysConfirm {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { results: fidl::new_empty!(fidl::encoding::UnboundedVector<SetKeyResult>, 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.
            fidl::decode!(
                fidl::encoding::UnboundedVector<SetKeyResult>,
                D,
                &mut self.results,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for SetKeysRequest {
        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<SetKeysRequest, D>
        for &SetKeysRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SetKeysRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SetKeysRequest, D>::encode(
                (
                    <fidl::encoding::UnboundedVector<SetKeyDescriptor> as fidl::encoding::ValueTypeMarker>::borrow(&self.keylist),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<SetKeyDescriptor>, D>,
    > fidl::encoding::Encode<SetKeysRequest, 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::<SetKeysRequest>(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 SetKeysRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { keylist: fidl::new_empty!(fidl::encoding::UnboundedVector<SetKeyDescriptor>, 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.
            fidl::decode!(
                fidl::encoding::UnboundedVector<SetKeyDescriptor>,
                D,
                &mut self.keylist,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<StartCaptureFramesRequest, D> for &StartCaptureFramesRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StartCaptureFramesRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<StartCaptureFramesRequest, D>::encode(
                (<MgmtFrameCaptureFlags as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.mgmt_frame_flags,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<MgmtFrameCaptureFlags, D>,
    > fidl::encoding::Encode<StartCaptureFramesRequest, 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::<StartCaptureFramesRequest>(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 StartCaptureFramesRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { mgmt_frame_flags: fidl::new_empty!(MgmtFrameCaptureFlags, 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.
            fidl::decode!(
                MgmtFrameCaptureFlags,
                D,
                &mut self.mgmt_frame_flags,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<StartCaptureFramesResponse, D> for &StartCaptureFramesResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StartCaptureFramesResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<StartCaptureFramesResponse, D>::encode(
                (
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
                    <MgmtFrameCaptureFlags as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.supported_mgmt_frames,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<i32, D>,
        T1: fidl::encoding::Encode<MgmtFrameCaptureFlags, D>,
    > fidl::encoding::Encode<StartCaptureFramesResponse, 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::<StartCaptureFramesResponse>(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 + 4, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for StartCaptureFramesResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                status: fidl::new_empty!(i32, D),
                supported_mgmt_frames: fidl::new_empty!(MgmtFrameCaptureFlags, 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.
            fidl::decode!(i32, D, &mut self.status, decoder, offset + 0, _depth)?;
            fidl::decode!(
                MgmtFrameCaptureFlags,
                D,
                &mut self.supported_mgmt_frames,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StartConfirm, D>
        for &StartConfirm
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StartConfirm>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<StartConfirm, D>::encode(
                (<StartResultCode as fidl::encoding::ValueTypeMarker>::borrow(&self.result_code),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StartResultCode, D>>
        fidl::encoding::Encode<StartConfirm, 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::<StartConfirm>(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 StartConfirm {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { result_code: fidl::new_empty!(StartResultCode, 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.
            fidl::decode!(StartResultCode, D, &mut self.result_code, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StartRequest, D>
        for &StartRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StartRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<StartRequest, D>::encode(
                (
                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.ssid),
                    <fidl_fuchsia_wlan_common__common::BssType as fidl::encoding::ValueTypeMarker>::borrow(&self.bss_type),
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.beacon_period),
                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.dtim_period),
                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.channel),
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.capability_info),
                    <fidl::encoding::Vector<u8, 14> as fidl::encoding::ValueTypeMarker>::borrow(&self.rates),
                    <Country as fidl::encoding::ValueTypeMarker>::borrow(&self.country),
                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.mesh_id),
                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>> as fidl::encoding::ValueTypeMarker>::borrow(&self.rsne),
                    <fidl_fuchsia_wlan_common__common::WlanPhyType as fidl::encoding::ValueTypeMarker>::borrow(&self.phy),
                    <fidl_fuchsia_wlan_ieee80211__common::ChannelBandwidth as fidl::encoding::ValueTypeMarker>::borrow(&self.channel_bandwidth),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 32>, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::BssType, D>,
        T2: fidl::encoding::Encode<u16, D>,
        T3: fidl::encoding::Encode<u8, D>,
        T4: fidl::encoding::Encode<u8, D>,
        T5: fidl::encoding::Encode<u16, D>,
        T6: fidl::encoding::Encode<fidl::encoding::Vector<u8, 14>, D>,
        T7: fidl::encoding::Encode<Country, D>,
        T8: fidl::encoding::Encode<fidl::encoding::Vector<u8, 32>, D>,
        T9: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>>, D>,
        T10: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::WlanPhyType, D>,
        T11: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::ChannelBandwidth, D>,
    > fidl::encoding::Encode<StartRequest, D>
        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StartRequest>(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(24);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 20, depth)?;
            self.3.encode(encoder, offset + 22, depth)?;
            self.4.encode(encoder, offset + 23, depth)?;
            self.5.encode(encoder, offset + 24, depth)?;
            self.6.encode(encoder, offset + 32, depth)?;
            self.7.encode(encoder, offset + 48, depth)?;
            self.8.encode(encoder, offset + 56, depth)?;
            self.9.encode(encoder, offset + 72, depth)?;
            self.10.encode(encoder, offset + 88, depth)?;
            self.11.encode(encoder, offset + 92, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                ssid: fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D),
                bss_type: fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssType, D),
                beacon_period: fidl::new_empty!(u16, D),
                dtim_period: fidl::new_empty!(u8, D),
                channel: fidl::new_empty!(u8, D),
                capability_info: fidl::new_empty!(u16, D),
                rates: fidl::new_empty!(fidl::encoding::Vector<u8, 14>, D),
                country: fidl::new_empty!(Country, D),
                mesh_id: fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D),
                rsne: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>>,
                    D
                ),
                phy: fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanPhyType, D),
                channel_bandwidth: fidl::new_empty!(
                    fidl_fuchsia_wlan_ieee80211__common::ChannelBandwidth,
                    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(24) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffffffff0000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffffff000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::Vector<u8, 32>, D, &mut self.ssid, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_wlan_common__common::BssType,
                D,
                &mut self.bss_type,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(u16, D, &mut self.beacon_period, decoder, offset + 20, _depth)?;
            fidl::decode!(u8, D, &mut self.dtim_period, decoder, offset + 22, _depth)?;
            fidl::decode!(u8, D, &mut self.channel, decoder, offset + 23, _depth)?;
            fidl::decode!(u16, D, &mut self.capability_info, decoder, offset + 24, _depth)?;
            fidl::decode!(fidl::encoding::Vector<u8, 14>, D, &mut self.rates, decoder, offset + 32, _depth)?;
            fidl::decode!(Country, D, &mut self.country, decoder, offset + 48, _depth)?;
            fidl::decode!(fidl::encoding::Vector<u8, 32>, D, &mut self.mesh_id, decoder, offset + 56, _depth)?;
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>>,
                D,
                &mut self.rsne,
                decoder,
                offset + 72,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_wlan_common__common::WlanPhyType,
                D,
                &mut self.phy,
                decoder,
                offset + 88,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_wlan_ieee80211__common::ChannelBandwidth,
                D,
                &mut self.channel_bandwidth,
                decoder,
                offset + 92,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StopConfirm, D>
        for &StopConfirm
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StopConfirm>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<StopConfirm, D>::encode(
                (<StopResultCode as fidl::encoding::ValueTypeMarker>::borrow(&self.result_code),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StopResultCode, D>>
        fidl::encoding::Encode<StopConfirm, 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::<StopConfirm>(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 StopConfirm {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { result_code: fidl::new_empty!(StopResultCode, 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.
            fidl::decode!(StopResultCode, D, &mut self.result_code, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for StopRequest {
        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<StopRequest, D>
        for &StopRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StopRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<StopRequest, D>::encode(
                (<fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.ssid,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 32>, D>,
    > fidl::encoding::Encode<StopRequest, 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::<StopRequest>(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 StopRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { ssid: fidl::new_empty!(fidl::encoding::Vector<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);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::Vector<u8, 32>, D, &mut self.ssid, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            18
        }
        #[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<WmmParameter, D>
        for &WmmParameter
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<WmmParameter>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut WmmParameter)
                    .write_unaligned((self as *const WmmParameter).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, 18>, D>,
    > fidl::encoding::Encode<WmmParameter, 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::<WmmParameter>(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 WmmParameter {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { bytes: fidl::new_empty!(fidl::encoding::Array<u8, 18>, 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, 18);
            }
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for GetIfaceHistogramStatsResponse {
        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<GetIfaceHistogramStatsResponse, D>
        for &GetIfaceHistogramStatsResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<GetIfaceHistogramStatsResponse>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            GetIfaceHistogramStatsResponse::Stats(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D>(
                    <fidl_fuchsia_wlan_stats__common::IfaceHistogramStats as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            GetIfaceHistogramStatsResponse::ErrorStatus(ref val) => {
                fidl::encoding::encode_in_envelope::<i32, D>(
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
        }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for GetIfaceHistogramStatsResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Stats(fidl::new_empty!(fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D))
        }

        #[inline]
        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);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
            1 => <fidl_fuchsia_wlan_stats__common::IfaceHistogramStats as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            _ => return Err(fidl::Error::UnknownUnionTag),
        };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let GetIfaceHistogramStatsResponse::Stats(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = GetIfaceHistogramStatsResponse::Stats(fidl::new_empty!(
                            fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let GetIfaceHistogramStatsResponse::Stats(ref mut val) = self {
                        fidl::decode!(
                            fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let GetIfaceHistogramStatsResponse::ErrorStatus(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            GetIfaceHistogramStatsResponse::ErrorStatus(fidl::new_empty!(i32, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let GetIfaceHistogramStatsResponse::ErrorStatus(ref mut val) = self {
                        fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            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);
            }
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for GetIfaceStatsResponse {
        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<GetIfaceStatsResponse, D>
        for &GetIfaceStatsResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<GetIfaceStatsResponse>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            GetIfaceStatsResponse::Stats(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl_fuchsia_wlan_stats__common::IfaceStats, D>(
                    <fidl_fuchsia_wlan_stats__common::IfaceStats as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            GetIfaceStatsResponse::ErrorStatus(ref val) => {
                fidl::encoding::encode_in_envelope::<i32, D>(
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
        }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GetIfaceStatsResponse {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Stats(fidl::new_empty!(fidl_fuchsia_wlan_stats__common::IfaceStats, D))
        }

        #[inline]
        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);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
            1 => <fidl_fuchsia_wlan_stats__common::IfaceStats as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            _ => return Err(fidl::Error::UnknownUnionTag),
        };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let GetIfaceStatsResponse::Stats(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = GetIfaceStatsResponse::Stats(fidl::new_empty!(
                            fidl_fuchsia_wlan_stats__common::IfaceStats,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let GetIfaceStatsResponse::Stats(ref mut val) = self {
                        fidl::decode!(
                            fidl_fuchsia_wlan_stats__common::IfaceStats,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let GetIfaceStatsResponse::ErrorStatus(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = GetIfaceStatsResponse::ErrorStatus(fidl::new_empty!(i32, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let GetIfaceStatsResponse::ErrorStatus(ref mut val) = self {
                        fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            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);
            }
            Ok(())
        }
    }
}