fidl_fuchsia_wlan_mlme/

fidl_fuchsia_wlan_mlme.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::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
pub use fidl_fuchsia_wlan_mlme__common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ConnectorConnectRequest {
    pub request: fidl::endpoints::ServerEnd<MlmeMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ConnectorConnectRequest {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ConnectorMarker;

impl fidl::endpoints::ProtocolMarker for ConnectorMarker {
    type Proxy = ConnectorProxy;
    type RequestStream = ConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Connector";
}

pub trait ConnectorProxyInterface: Send + Sync {
    fn r#connect(&self, request: fidl::endpoints::ServerEnd<MlmeMarker>)
    -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ConnectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ConnectorSynchronousProxy {
    type Proxy = ConnectorProxy;
    type Protocol = ConnectorMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl ConnectorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<ConnectorEvent, fidl::Error> {
        ConnectorEvent::decode(self.client.wait_for_event::<ConnectorMarker>(deadline)?)
    }

    pub fn r#connect(
        &self,
        mut request: fidl::endpoints::ServerEnd<MlmeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ConnectorConnectRequest>(
            (request,),
            0x42131859717af962,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[cfg(target_os = "fuchsia")]
impl From<ConnectorSynchronousProxy> for zx::NullableHandle {
    fn from(value: ConnectorSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for ConnectorSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for ConnectorSynchronousProxy {
    type Protocol = ConnectorMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<ConnectorMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct ConnectorProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for ConnectorProxy {
    type Protocol = ConnectorMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl ConnectorProxy {
    /// Create a new Proxy for fuchsia.wlan.mlme/Connector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ConnectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> ConnectorEventStream {
        ConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#connect(
        &self,
        mut request: fidl::endpoints::ServerEnd<MlmeMarker>,
    ) -> Result<(), fidl::Error> {
        ConnectorProxyInterface::r#connect(self, request)
    }
}

impl ConnectorProxyInterface for ConnectorProxy {
    fn r#connect(
        &self,
        mut request: fidl::endpoints::ServerEnd<MlmeMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ConnectorConnectRequest>(
            (request,),
            0x42131859717af962,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct ConnectorEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for ConnectorEventStream {}

impl futures::stream::FusedStream for ConnectorEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for ConnectorEventStream {
    type Item = Result<ConnectorEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(ConnectorEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum ConnectorEvent {}

impl ConnectorEvent {
    /// Decodes a message buffer as a [`ConnectorEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ConnectorEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <ConnectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.wlan.mlme/Connector.
pub struct ConnectorRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for ConnectorRequestStream {}

impl futures::stream::FusedStream for ConnectorRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for ConnectorRequestStream {
    type Protocol = ConnectorMarker;
    type ControlHandle = ConnectorControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        ConnectorControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for ConnectorRequestStream {
    type Item = Result<ConnectorRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled ConnectorRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x42131859717af962 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ConnectorConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ConnectorConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ConnectorControlHandle { inner: this.inner.clone() };
                        Ok(ConnectorRequest::Connect { request: req.request, control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ConnectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// This protocol is used to connect to the interface's underlying MLME.
#[derive(Debug)]
pub enum ConnectorRequest {
    Connect {
        request: fidl::endpoints::ServerEnd<MlmeMarker>,
        control_handle: ConnectorControlHandle,
    },
}

impl ConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<MlmeMarker>, ConnectorControlHandle)> {
        if let ConnectorRequest::Connect { request, control_handle } = self {
            Some((request, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ConnectorRequest::Connect { .. } => "connect",
        }
    }
}

#[derive(Debug, Clone)]
pub struct ConnectorControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for ConnectorControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl ConnectorControlHandle {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct MlmeMarker;

impl fidl::endpoints::ProtocolMarker for MlmeMarker {
    type Proxy = MlmeProxy;
    type RequestStream = MlmeRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = MlmeSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Mlme";
}
pub type MlmeStartScheduledScanResult = Result<(), i32>;
pub type MlmeStopScheduledScanResult = Result<(), i32>;
pub type MlmeGetScheduledScanEnabledResult = Result<Vec<u64>, i32>;
pub type MlmeQueryTelemetrySupportResult = Result<fidl_fuchsia_wlan_stats::TelemetrySupport, i32>;
pub type MlmeGetSignalReportResult = Result<fidl_fuchsia_wlan_stats::SignalReport, i32>;
pub type MlmeSetMacAddressResult = Result<(), i32>;
pub type MlmeInstallApfPacketFilterResult = Result<(), i32>;
pub type MlmeReadApfPacketFilterDataResult = Result<Vec<u8>, i32>;
pub type MlmeSetApfPacketFilterEnabledResult = Result<(), i32>;
pub type MlmeGetApfPacketFilterEnabledResult = Result<bool, i32>;

pub trait MlmeProxyInterface: Send + Sync {
    fn r#start_scan(&self, req: &ScanRequest) -> Result<(), fidl::Error>;
    type StartScheduledScanResponseFut: std::future::Future<Output = Result<MlmeStartScheduledScanResult, fidl::Error>>
        + Send;
    fn r#start_scheduled_scan(
        &self,
        txn_id: u64,
        req: &fidl_fuchsia_wlan_common::ScheduledScanRequest,
    ) -> Self::StartScheduledScanResponseFut;
    type StopScheduledScanResponseFut: std::future::Future<Output = Result<MlmeStopScheduledScanResult, fidl::Error>>
        + Send;
    fn r#stop_scheduled_scan(&self, txn_id: u64) -> Self::StopScheduledScanResponseFut;
    type GetScheduledScanEnabledResponseFut: std::future::Future<Output = Result<MlmeGetScheduledScanEnabledResult, fidl::Error>>
        + Send;
    fn r#get_scheduled_scan_enabled(&self) -> Self::GetScheduledScanEnabledResponseFut;
    fn r#connect_req(&self, req: &ConnectRequest) -> Result<(), fidl::Error>;
    fn r#reconnect_req(&self, req: &ReconnectRequest) -> Result<(), fidl::Error>;
    fn r#roam_req(&self, req: &RoamRequest) -> Result<(), fidl::Error>;
    fn r#authenticate_resp(&self, resp: &AuthenticateResponse) -> Result<(), fidl::Error>;
    fn r#deauthenticate_req(&self, req: &DeauthenticateRequest) -> Result<(), fidl::Error>;
    fn r#associate_resp(&self, resp: &AssociateResponse) -> Result<(), fidl::Error>;
    fn r#disassociate_req(&self, req: &DisassociateRequest) -> Result<(), fidl::Error>;
    fn r#reset_req(&self, req: &ResetRequest) -> Result<(), fidl::Error>;
    fn r#start_req(&self, req: &StartRequest) -> Result<(), fidl::Error>;
    fn r#stop_req(&self, req: &StopRequest) -> Result<(), fidl::Error>;
    fn r#set_keys_req(&self, req: &SetKeysRequest) -> Result<(), fidl::Error>;
    fn r#delete_keys_req(&self, req: &DeleteKeysRequest) -> Result<(), fidl::Error>;
    fn r#eapol_req(&self, req: &EapolRequest) -> Result<(), fidl::Error>;
    fn r#set_controlled_port(&self, req: &SetControlledPortRequest) -> Result<(), fidl::Error>;
    type QueryDeviceInfoResponseFut: std::future::Future<Output = Result<DeviceInfo, fidl::Error>>
        + Send;
    fn r#query_device_info(&self) -> Self::QueryDeviceInfoResponseFut;
    type QueryTelemetrySupportResponseFut: std::future::Future<Output = Result<MlmeQueryTelemetrySupportResult, fidl::Error>>
        + Send;
    fn r#query_telemetry_support(&self) -> Self::QueryTelemetrySupportResponseFut;
    type GetIfaceStatsResponseFut: std::future::Future<Output = Result<GetIfaceStatsResponse, fidl::Error>>
        + Send;
    fn r#get_iface_stats(&self) -> Self::GetIfaceStatsResponseFut;
    type GetIfaceHistogramStatsResponseFut: std::future::Future<Output = Result<GetIfaceHistogramStatsResponse, fidl::Error>>
        + Send;
    fn r#get_iface_histogram_stats(&self) -> Self::GetIfaceHistogramStatsResponseFut;
    type GetSignalReportResponseFut: std::future::Future<Output = Result<MlmeGetSignalReportResult, fidl::Error>>
        + Send;
    fn r#get_signal_report(&self) -> Self::GetSignalReportResponseFut;
    type ListMinstrelPeersResponseFut: std::future::Future<Output = Result<MinstrelListResponse, fidl::Error>>
        + Send;
    fn r#list_minstrel_peers(&self) -> Self::ListMinstrelPeersResponseFut;
    type GetMinstrelStatsResponseFut: std::future::Future<Output = Result<MinstrelStatsResponse, fidl::Error>>
        + Send;
    fn r#get_minstrel_stats(&self, req: &MinstrelStatsRequest)
    -> Self::GetMinstrelStatsResponseFut;
    type StartCaptureFramesResponseFut: std::future::Future<Output = Result<StartCaptureFramesResponse, fidl::Error>>
        + Send;
    fn r#start_capture_frames(
        &self,
        req: &StartCaptureFramesRequest,
    ) -> Self::StartCaptureFramesResponseFut;
    fn r#stop_capture_frames(&self) -> Result<(), fidl::Error>;
    fn r#sae_handshake_resp(&self, resp: &SaeHandshakeResponse) -> Result<(), fidl::Error>;
    fn r#sae_frame_tx(&self, frame: &SaeFrame) -> Result<(), fidl::Error>;
    fn r#wmm_status_req(&self) -> Result<(), fidl::Error>;
    fn r#finalize_association_req(
        &self,
        negotiated_capabilities: &NegotiatedCapabilities,
    ) -> Result<(), fidl::Error>;
    type SetMacAddressResponseFut: std::future::Future<Output = Result<MlmeSetMacAddressResult, fidl::Error>>
        + Send;
    fn r#set_mac_address(&self, mac_addr: &[u8; 6]) -> Self::SetMacAddressResponseFut;
    type InstallApfPacketFilterResponseFut: std::future::Future<Output = Result<MlmeInstallApfPacketFilterResult, fidl::Error>>
        + Send;
    fn r#install_apf_packet_filter(
        &self,
        program: &[u8],
    ) -> Self::InstallApfPacketFilterResponseFut;
    type ReadApfPacketFilterDataResponseFut: std::future::Future<Output = Result<MlmeReadApfPacketFilterDataResult, fidl::Error>>
        + Send;
    fn r#read_apf_packet_filter_data(&self) -> Self::ReadApfPacketFilterDataResponseFut;
    type SetApfPacketFilterEnabledResponseFut: std::future::Future<Output = Result<MlmeSetApfPacketFilterEnabledResult, fidl::Error>>
        + Send;
    fn r#set_apf_packet_filter_enabled(
        &self,
        enabled: bool,
    ) -> Self::SetApfPacketFilterEnabledResponseFut;
    type GetApfPacketFilterEnabledResponseFut: std::future::Future<Output = Result<MlmeGetApfPacketFilterEnabledResult, fidl::Error>>
        + Send;
    fn r#get_apf_packet_filter_enabled(&self) -> Self::GetApfPacketFilterEnabledResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct MlmeSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for MlmeSynchronousProxy {
    type Proxy = MlmeProxy;
    type Protocol = MlmeMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl MlmeSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(&self, deadline: zx::MonotonicInstant) -> Result<MlmeEvent, fidl::Error> {
        MlmeEvent::decode(self.client.wait_for_event::<MlmeMarker>(deadline)?)
    }

    pub fn r#start_scan(&self, mut req: &ScanRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeStartScanRequest>(
            (req,),
            0x342cc5ec6a957479,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Starts scheduled scanning.
    pub fn r#start_scheduled_scan(
        &self,
        mut txn_id: u64,
        mut req: &fidl_fuchsia_wlan_common::ScheduledScanRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MlmeStartScheduledScanResult, fidl::Error> {
        let _response = self.client.send_query::<
            MlmeStartScheduledScanRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            MlmeMarker,
        >(
            (txn_id, req,),
            0x7fff163af4620212,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Stops scheduled scanning.
    pub fn r#stop_scheduled_scan(
        &self,
        mut txn_id: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MlmeStopScheduledScanResult, fidl::Error> {
        let _response = self.client.send_query::<
            MlmeStopScheduledScanRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            MlmeMarker,
        >(
            (txn_id,),
            0x5fbc466f3daa4dd9,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Returns the transaction IDs of any currently active scheduled scans.
    pub fn r#get_scheduled_scan_enabled(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MlmeGetScheduledScanEnabledResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<MlmeGetScheduledScanEnabledResponse, i32>,
            MlmeMarker,
        >(
            (),
            0x1ecc6a7fe7f9fcff,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.active_txn_ids))
    }

    pub fn r#connect_req(&self, mut req: &ConnectRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeConnectReqRequest>(
            (req,),
            0x31153dc85f8f64c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#reconnect_req(&self, mut req: &ReconnectRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeReconnectReqRequest>(
            (req,),
            0x74e0f1bd758b6b78,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Initiate a roam attempt (SME-initiated).
    pub fn r#roam_req(&self, mut req: &RoamRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeRoamReqRequest>(
            (req,),
            0x3ba163eadf7dba45,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#authenticate_resp(&self, mut resp: &AuthenticateResponse) -> Result<(), fidl::Error> {
        self.client.send::<MlmeAuthenticateRespRequest>(
            (resp,),
            0x26108aade2fdd2f4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#deauthenticate_req(&self, mut req: &DeauthenticateRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeDeauthenticateReqRequest>(
            (req,),
            0x228983b200de5d12,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#associate_resp(&self, mut resp: &AssociateResponse) -> Result<(), fidl::Error> {
        self.client.send::<MlmeAssociateRespRequest>(
            (resp,),
            0x70244dbd652ed6d9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#disassociate_req(&self, mut req: &DisassociateRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeDisassociateReqRequest>(
            (req,),
            0x5765807f1387d764,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#reset_req(&self, mut req: &ResetRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeResetReqRequest>(
            (req,),
            0x780b98c58a286b9f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#start_req(&self, mut req: &StartRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeStartReqRequest>(
            (req,),
            0x5d95885f8053654,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#stop_req(&self, mut req: &StopRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeStopReqRequest>(
            (req,),
            0x27b9a2ab04a2c79f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#set_keys_req(&self, mut req: &SetKeysRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeSetKeysReqRequest>(
            (req,),
            0x6b30a07fd3a11a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#delete_keys_req(&self, mut req: &DeleteKeysRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeDeleteKeysReqRequest>(
            (req,),
            0x1e3524d20d190c8f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#eapol_req(&self, mut req: &EapolRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeEapolReqRequest>(
            (req,),
            0xc3c096924704d4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#set_controlled_port(
        &self,
        mut req: &SetControlledPortRequest,
    ) -> Result<(), fidl::Error> {
        self.client.send::<MlmeSetControlledPortRequest>(
            (req,),
            0x4e47065668890c8d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#query_device_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceInfo, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, MlmeQueryDeviceInfoResponse, MlmeMarker>(
                (),
                0x6ee3e7f63f2b7bc0,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.info)
    }

    pub fn r#query_telemetry_support(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MlmeQueryTelemetrySupportResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<MlmeQueryTelemetrySupportResponse, i32>,
            MlmeMarker,
        >(
            (),
            0x1598879b70332c99,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.resp))
    }

    pub fn r#get_iface_stats(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GetIfaceStatsResponse, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, MlmeGetIfaceStatsResponse, MlmeMarker>(
                (),
                0xede1a8342d1b211,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.resp)
    }

    pub fn r#get_iface_histogram_stats(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GetIfaceHistogramStatsResponse, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            MlmeGetIfaceHistogramStatsResponse,
            MlmeMarker,
        >(
            (),
            0x1979c9d3449f8675,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.resp)
    }

    pub fn r#get_signal_report(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MlmeGetSignalReportResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<MlmeGetSignalReportResponse, i32>,
            MlmeMarker,
        >(
            (),
            0x7e47e7ebe92acec9,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.resp))
    }

    pub fn r#list_minstrel_peers(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MinstrelListResponse, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, MlmeListMinstrelPeersResponse, MlmeMarker>(
                (),
                0x4ac5d1e66fe1ffd5,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.resp)
    }

    pub fn r#get_minstrel_stats(
        &self,
        mut req: &MinstrelStatsRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MinstrelStatsResponse, fidl::Error> {
        let _response = self
            .client
            .send_query::<MlmeGetMinstrelStatsRequest, MlmeGetMinstrelStatsResponse, MlmeMarker>(
                (req,),
                0x2f688b1245323f4b,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.resp)
    }

    pub fn r#start_capture_frames(
        &self,
        mut req: &StartCaptureFramesRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StartCaptureFramesResponse, fidl::Error> {
        let _response = self.client.send_query::<
            MlmeStartCaptureFramesRequest,
            MlmeStartCaptureFramesResponse,
            MlmeMarker,
        >(
            (req,),
            0x23b369ed5749ee69,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.resp)
    }

    pub fn r#stop_capture_frames(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x2f1aebbc68bf7c54,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Notifies that SAE authentication is completed.
    pub fn r#sae_handshake_resp(&self, mut resp: &SaeHandshakeResponse) -> Result<(), fidl::Error> {
        self.client.send::<MlmeSaeHandshakeRespRequest>(
            (resp,),
            0x28477bd2f7a5ab0c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Transmits SAE frame (if SME is managing SAE authentication).
    pub fn r#sae_frame_tx(&self, mut frame: &SaeFrame) -> Result<(), fidl::Error> {
        self.client.send::<MlmeSaeFrameTxRequest>(
            (frame,),
            0x7700c0d536733d8c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#wmm_status_req(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0xef4851f6088fede,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#finalize_association_req(
        &self,
        mut negotiated_capabilities: &NegotiatedCapabilities,
    ) -> Result<(), fidl::Error> {
        self.client.send::<MlmeFinalizeAssociationReqRequest>(
            (negotiated_capabilities,),
            0x7aea59787cfd385a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#set_mac_address(
        &self,
        mut mac_addr: &[u8; 6],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MlmeSetMacAddressResult, fidl::Error> {
        let _response = self.client.send_query::<
            MlmeSetMacAddressRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            MlmeMarker,
        >(
            (mac_addr,),
            0x476999f9bb27afe1,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#install_apf_packet_filter(
        &self,
        mut program: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MlmeInstallApfPacketFilterResult, fidl::Error> {
        let _response = self.client.send_query::<
            MlmeInstallApfPacketFilterRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            MlmeMarker,
        >(
            (program,),
            0x267565b4916c825b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#read_apf_packet_filter_data(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MlmeReadApfPacketFilterDataResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<MlmeReadApfPacketFilterDataResponse, i32>,
            MlmeMarker,
        >(
            (),
            0x6040d744f1b2cb61,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.memory))
    }

    pub fn r#set_apf_packet_filter_enabled(
        &self,
        mut enabled: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MlmeSetApfPacketFilterEnabledResult, fidl::Error> {
        let _response = self.client.send_query::<
            MlmeSetApfPacketFilterEnabledRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            MlmeMarker,
        >(
            (enabled,),
            0x6d99bdca77076aea,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#get_apf_packet_filter_enabled(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MlmeGetApfPacketFilterEnabledResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<MlmeGetApfPacketFilterEnabledResponse, i32>,
            MlmeMarker,
        >(
            (),
            0x1df408bc154be1e4,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.enabled))
    }
}

#[cfg(target_os = "fuchsia")]
impl From<MlmeSynchronousProxy> for zx::NullableHandle {
    fn from(value: MlmeSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for MlmeSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for MlmeSynchronousProxy {
    type Protocol = MlmeMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<MlmeMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct MlmeProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for MlmeProxy {
    type Protocol = MlmeMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl MlmeProxy {
    /// Create a new Proxy for fuchsia.wlan.mlme/MLME.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <MlmeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> MlmeEventStream {
        MlmeEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#start_scan(&self, mut req: &ScanRequest) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#start_scan(self, req)
    }

    /// Starts scheduled scanning.
    pub fn r#start_scheduled_scan(
        &self,
        mut txn_id: u64,
        mut req: &fidl_fuchsia_wlan_common::ScheduledScanRequest,
    ) -> fidl::client::QueryResponseFut<
        MlmeStartScheduledScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MlmeProxyInterface::r#start_scheduled_scan(self, txn_id, req)
    }

    /// Stops scheduled scanning.
    pub fn r#stop_scheduled_scan(
        &self,
        mut txn_id: u64,
    ) -> fidl::client::QueryResponseFut<
        MlmeStopScheduledScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MlmeProxyInterface::r#stop_scheduled_scan(self, txn_id)
    }

    /// Returns the transaction IDs of any currently active scheduled scans.
    pub fn r#get_scheduled_scan_enabled(
        &self,
    ) -> fidl::client::QueryResponseFut<
        MlmeGetScheduledScanEnabledResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MlmeProxyInterface::r#get_scheduled_scan_enabled(self)
    }

    pub fn r#connect_req(&self, mut req: &ConnectRequest) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#connect_req(self, req)
    }

    pub fn r#reconnect_req(&self, mut req: &ReconnectRequest) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#reconnect_req(self, req)
    }

    /// Initiate a roam attempt (SME-initiated).
    pub fn r#roam_req(&self, mut req: &RoamRequest) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#roam_req(self, req)
    }

    pub fn r#authenticate_resp(&self, mut resp: &AuthenticateResponse) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#authenticate_resp(self, resp)
    }

    pub fn r#deauthenticate_req(&self, mut req: &DeauthenticateRequest) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#deauthenticate_req(self, req)
    }

    pub fn r#associate_resp(&self, mut resp: &AssociateResponse) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#associate_resp(self, resp)
    }

    pub fn r#disassociate_req(&self, mut req: &DisassociateRequest) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#disassociate_req(self, req)
    }

    pub fn r#reset_req(&self, mut req: &ResetRequest) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#reset_req(self, req)
    }

    pub fn r#start_req(&self, mut req: &StartRequest) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#start_req(self, req)
    }

    pub fn r#stop_req(&self, mut req: &StopRequest) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#stop_req(self, req)
    }

    pub fn r#set_keys_req(&self, mut req: &SetKeysRequest) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#set_keys_req(self, req)
    }

    pub fn r#delete_keys_req(&self, mut req: &DeleteKeysRequest) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#delete_keys_req(self, req)
    }

    pub fn r#eapol_req(&self, mut req: &EapolRequest) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#eapol_req(self, req)
    }

    pub fn r#set_controlled_port(
        &self,
        mut req: &SetControlledPortRequest,
    ) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#set_controlled_port(self, req)
    }

    pub fn r#query_device_info(
        &self,
    ) -> fidl::client::QueryResponseFut<DeviceInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        MlmeProxyInterface::r#query_device_info(self)
    }

    pub fn r#query_telemetry_support(
        &self,
    ) -> fidl::client::QueryResponseFut<
        MlmeQueryTelemetrySupportResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MlmeProxyInterface::r#query_telemetry_support(self)
    }

    pub fn r#get_iface_stats(
        &self,
    ) -> fidl::client::QueryResponseFut<
        GetIfaceStatsResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MlmeProxyInterface::r#get_iface_stats(self)
    }

    pub fn r#get_iface_histogram_stats(
        &self,
    ) -> fidl::client::QueryResponseFut<
        GetIfaceHistogramStatsResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MlmeProxyInterface::r#get_iface_histogram_stats(self)
    }

    pub fn r#get_signal_report(
        &self,
    ) -> fidl::client::QueryResponseFut<
        MlmeGetSignalReportResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MlmeProxyInterface::r#get_signal_report(self)
    }

    pub fn r#list_minstrel_peers(
        &self,
    ) -> fidl::client::QueryResponseFut<
        MinstrelListResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MlmeProxyInterface::r#list_minstrel_peers(self)
    }

    pub fn r#get_minstrel_stats(
        &self,
        mut req: &MinstrelStatsRequest,
    ) -> fidl::client::QueryResponseFut<
        MinstrelStatsResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MlmeProxyInterface::r#get_minstrel_stats(self, req)
    }

    pub fn r#start_capture_frames(
        &self,
        mut req: &StartCaptureFramesRequest,
    ) -> fidl::client::QueryResponseFut<
        StartCaptureFramesResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MlmeProxyInterface::r#start_capture_frames(self, req)
    }

    pub fn r#stop_capture_frames(&self) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#stop_capture_frames(self)
    }

    /// Notifies that SAE authentication is completed.
    pub fn r#sae_handshake_resp(&self, mut resp: &SaeHandshakeResponse) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#sae_handshake_resp(self, resp)
    }

    /// Transmits SAE frame (if SME is managing SAE authentication).
    pub fn r#sae_frame_tx(&self, mut frame: &SaeFrame) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#sae_frame_tx(self, frame)
    }

    pub fn r#wmm_status_req(&self) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#wmm_status_req(self)
    }

    pub fn r#finalize_association_req(
        &self,
        mut negotiated_capabilities: &NegotiatedCapabilities,
    ) -> Result<(), fidl::Error> {
        MlmeProxyInterface::r#finalize_association_req(self, negotiated_capabilities)
    }

    pub fn r#set_mac_address(
        &self,
        mut mac_addr: &[u8; 6],
    ) -> fidl::client::QueryResponseFut<
        MlmeSetMacAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MlmeProxyInterface::r#set_mac_address(self, mac_addr)
    }

    pub fn r#install_apf_packet_filter(
        &self,
        mut program: &[u8],
    ) -> fidl::client::QueryResponseFut<
        MlmeInstallApfPacketFilterResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MlmeProxyInterface::r#install_apf_packet_filter(self, program)
    }

    pub fn r#read_apf_packet_filter_data(
        &self,
    ) -> fidl::client::QueryResponseFut<
        MlmeReadApfPacketFilterDataResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MlmeProxyInterface::r#read_apf_packet_filter_data(self)
    }

    pub fn r#set_apf_packet_filter_enabled(
        &self,
        mut enabled: bool,
    ) -> fidl::client::QueryResponseFut<
        MlmeSetApfPacketFilterEnabledResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MlmeProxyInterface::r#set_apf_packet_filter_enabled(self, enabled)
    }

    pub fn r#get_apf_packet_filter_enabled(
        &self,
    ) -> fidl::client::QueryResponseFut<
        MlmeGetApfPacketFilterEnabledResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MlmeProxyInterface::r#get_apf_packet_filter_enabled(self)
    }
}

impl MlmeProxyInterface for MlmeProxy {
    fn r#start_scan(&self, mut req: &ScanRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeStartScanRequest>(
            (req,),
            0x342cc5ec6a957479,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type StartScheduledScanResponseFut = fidl::client::QueryResponseFut<
        MlmeStartScheduledScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start_scheduled_scan(
        &self,
        mut txn_id: u64,
        mut req: &fidl_fuchsia_wlan_common::ScheduledScanRequest,
    ) -> Self::StartScheduledScanResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MlmeStartScheduledScanResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7fff163af4620212,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<MlmeStartScheduledScanRequest, MlmeStartScheduledScanResult>(
                (txn_id, req),
                0x7fff163af4620212,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type StopScheduledScanResponseFut = fidl::client::QueryResponseFut<
        MlmeStopScheduledScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#stop_scheduled_scan(&self, mut txn_id: u64) -> Self::StopScheduledScanResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MlmeStopScheduledScanResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5fbc466f3daa4dd9,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<MlmeStopScheduledScanRequest, MlmeStopScheduledScanResult>(
                (txn_id,),
                0x5fbc466f3daa4dd9,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetScheduledScanEnabledResponseFut = fidl::client::QueryResponseFut<
        MlmeGetScheduledScanEnabledResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_scheduled_scan_enabled(&self) -> Self::GetScheduledScanEnabledResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MlmeGetScheduledScanEnabledResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<MlmeGetScheduledScanEnabledResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ecc6a7fe7f9fcff,
            >(_buf?)?;
            Ok(_response.map(|x| x.active_txn_ids))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            MlmeGetScheduledScanEnabledResult,
        >(
            (),
            0x1ecc6a7fe7f9fcff,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#connect_req(&self, mut req: &ConnectRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeConnectReqRequest>(
            (req,),
            0x31153dc85f8f64c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#reconnect_req(&self, mut req: &ReconnectRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeReconnectReqRequest>(
            (req,),
            0x74e0f1bd758b6b78,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#roam_req(&self, mut req: &RoamRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeRoamReqRequest>(
            (req,),
            0x3ba163eadf7dba45,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#authenticate_resp(&self, mut resp: &AuthenticateResponse) -> Result<(), fidl::Error> {
        self.client.send::<MlmeAuthenticateRespRequest>(
            (resp,),
            0x26108aade2fdd2f4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#deauthenticate_req(&self, mut req: &DeauthenticateRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeDeauthenticateReqRequest>(
            (req,),
            0x228983b200de5d12,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#associate_resp(&self, mut resp: &AssociateResponse) -> Result<(), fidl::Error> {
        self.client.send::<MlmeAssociateRespRequest>(
            (resp,),
            0x70244dbd652ed6d9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#disassociate_req(&self, mut req: &DisassociateRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeDisassociateReqRequest>(
            (req,),
            0x5765807f1387d764,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#reset_req(&self, mut req: &ResetRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeResetReqRequest>(
            (req,),
            0x780b98c58a286b9f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#start_req(&self, mut req: &StartRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeStartReqRequest>(
            (req,),
            0x5d95885f8053654,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#stop_req(&self, mut req: &StopRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeStopReqRequest>(
            (req,),
            0x27b9a2ab04a2c79f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_keys_req(&self, mut req: &SetKeysRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeSetKeysReqRequest>(
            (req,),
            0x6b30a07fd3a11a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#delete_keys_req(&self, mut req: &DeleteKeysRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeDeleteKeysReqRequest>(
            (req,),
            0x1e3524d20d190c8f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#eapol_req(&self, mut req: &EapolRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeEapolReqRequest>(
            (req,),
            0xc3c096924704d4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_controlled_port(&self, mut req: &SetControlledPortRequest) -> Result<(), fidl::Error> {
        self.client.send::<MlmeSetControlledPortRequest>(
            (req,),
            0x4e47065668890c8d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type QueryDeviceInfoResponseFut =
        fidl::client::QueryResponseFut<DeviceInfo, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#query_device_info(&self) -> Self::QueryDeviceInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                MlmeQueryDeviceInfoResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ee3e7f63f2b7bc0,
            >(_buf?)?;
            Ok(_response.info)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, DeviceInfo>(
            (),
            0x6ee3e7f63f2b7bc0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryTelemetrySupportResponseFut = fidl::client::QueryResponseFut<
        MlmeQueryTelemetrySupportResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query_telemetry_support(&self) -> Self::QueryTelemetrySupportResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MlmeQueryTelemetrySupportResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<MlmeQueryTelemetrySupportResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1598879b70332c99,
            >(_buf?)?;
            Ok(_response.map(|x| x.resp))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, MlmeQueryTelemetrySupportResult>(
                (),
                0x1598879b70332c99,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetIfaceStatsResponseFut = fidl::client::QueryResponseFut<
        GetIfaceStatsResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_iface_stats(&self) -> Self::GetIfaceStatsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GetIfaceStatsResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                MlmeGetIfaceStatsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xede1a8342d1b211,
            >(_buf?)?;
            Ok(_response.resp)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, GetIfaceStatsResponse>(
            (),
            0xede1a8342d1b211,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIfaceHistogramStatsResponseFut = fidl::client::QueryResponseFut<
        GetIfaceHistogramStatsResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_iface_histogram_stats(&self) -> Self::GetIfaceHistogramStatsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GetIfaceHistogramStatsResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                MlmeGetIfaceHistogramStatsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1979c9d3449f8675,
            >(_buf?)?;
            Ok(_response.resp)
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, GetIfaceHistogramStatsResponse>(
                (),
                0x1979c9d3449f8675,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetSignalReportResponseFut = fidl::client::QueryResponseFut<
        MlmeGetSignalReportResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_signal_report(&self) -> Self::GetSignalReportResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MlmeGetSignalReportResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<MlmeGetSignalReportResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7e47e7ebe92acec9,
            >(_buf?)?;
            Ok(_response.map(|x| x.resp))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, MlmeGetSignalReportResult>(
                (),
                0x7e47e7ebe92acec9,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ListMinstrelPeersResponseFut = fidl::client::QueryResponseFut<
        MinstrelListResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#list_minstrel_peers(&self) -> Self::ListMinstrelPeersResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MinstrelListResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                MlmeListMinstrelPeersResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4ac5d1e66fe1ffd5,
            >(_buf?)?;
            Ok(_response.resp)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, MinstrelListResponse>(
            (),
            0x4ac5d1e66fe1ffd5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetMinstrelStatsResponseFut = fidl::client::QueryResponseFut<
        MinstrelStatsResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_minstrel_stats(
        &self,
        mut req: &MinstrelStatsRequest,
    ) -> Self::GetMinstrelStatsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MinstrelStatsResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                MlmeGetMinstrelStatsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2f688b1245323f4b,
            >(_buf?)?;
            Ok(_response.resp)
        }
        self.client.send_query_and_decode::<MlmeGetMinstrelStatsRequest, MinstrelStatsResponse>(
            (req,),
            0x2f688b1245323f4b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartCaptureFramesResponseFut = fidl::client::QueryResponseFut<
        StartCaptureFramesResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start_capture_frames(
        &self,
        mut req: &StartCaptureFramesRequest,
    ) -> Self::StartCaptureFramesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StartCaptureFramesResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                MlmeStartCaptureFramesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x23b369ed5749ee69,
            >(_buf?)?;
            Ok(_response.resp)
        }
        self.client
            .send_query_and_decode::<MlmeStartCaptureFramesRequest, StartCaptureFramesResponse>(
                (req,),
                0x23b369ed5749ee69,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    fn r#stop_capture_frames(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x2f1aebbc68bf7c54,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#sae_handshake_resp(&self, mut resp: &SaeHandshakeResponse) -> Result<(), fidl::Error> {
        self.client.send::<MlmeSaeHandshakeRespRequest>(
            (resp,),
            0x28477bd2f7a5ab0c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#sae_frame_tx(&self, mut frame: &SaeFrame) -> Result<(), fidl::Error> {
        self.client.send::<MlmeSaeFrameTxRequest>(
            (frame,),
            0x7700c0d536733d8c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#wmm_status_req(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0xef4851f6088fede,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#finalize_association_req(
        &self,
        mut negotiated_capabilities: &NegotiatedCapabilities,
    ) -> Result<(), fidl::Error> {
        self.client.send::<MlmeFinalizeAssociationReqRequest>(
            (negotiated_capabilities,),
            0x7aea59787cfd385a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type SetMacAddressResponseFut = fidl::client::QueryResponseFut<
        MlmeSetMacAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_mac_address(&self, mut mac_addr: &[u8; 6]) -> Self::SetMacAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MlmeSetMacAddressResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x476999f9bb27afe1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<MlmeSetMacAddressRequest, MlmeSetMacAddressResult>(
            (mac_addr,),
            0x476999f9bb27afe1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type InstallApfPacketFilterResponseFut = fidl::client::QueryResponseFut<
        MlmeInstallApfPacketFilterResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#install_apf_packet_filter(
        &self,
        mut program: &[u8],
    ) -> Self::InstallApfPacketFilterResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MlmeInstallApfPacketFilterResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x267565b4916c825b,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            MlmeInstallApfPacketFilterRequest,
            MlmeInstallApfPacketFilterResult,
        >(
            (program,),
            0x267565b4916c825b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReadApfPacketFilterDataResponseFut = fidl::client::QueryResponseFut<
        MlmeReadApfPacketFilterDataResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_apf_packet_filter_data(&self) -> Self::ReadApfPacketFilterDataResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MlmeReadApfPacketFilterDataResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<MlmeReadApfPacketFilterDataResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6040d744f1b2cb61,
            >(_buf?)?;
            Ok(_response.map(|x| x.memory))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            MlmeReadApfPacketFilterDataResult,
        >(
            (),
            0x6040d744f1b2cb61,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetApfPacketFilterEnabledResponseFut = fidl::client::QueryResponseFut<
        MlmeSetApfPacketFilterEnabledResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_apf_packet_filter_enabled(
        &self,
        mut enabled: bool,
    ) -> Self::SetApfPacketFilterEnabledResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MlmeSetApfPacketFilterEnabledResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6d99bdca77076aea,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            MlmeSetApfPacketFilterEnabledRequest,
            MlmeSetApfPacketFilterEnabledResult,
        >(
            (enabled,),
            0x6d99bdca77076aea,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetApfPacketFilterEnabledResponseFut = fidl::client::QueryResponseFut<
        MlmeGetApfPacketFilterEnabledResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_apf_packet_filter_enabled(&self) -> Self::GetApfPacketFilterEnabledResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MlmeGetApfPacketFilterEnabledResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<MlmeGetApfPacketFilterEnabledResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1df408bc154be1e4,
            >(_buf?)?;
            Ok(_response.map(|x| x.enabled))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            MlmeGetApfPacketFilterEnabledResult,
        >(
            (),
            0x1df408bc154be1e4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct MlmeEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for MlmeEventStream {}

impl futures::stream::FusedStream for MlmeEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for MlmeEventStream {
    type Item = Result<MlmeEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(MlmeEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum MlmeEvent {
    OnScanResult { result: ScanResult },
    OnScanEnd { end: ScanEnd },
    OnScheduledScanMatchesAvailable { txn_id: u64 },
    OnScheduledScanStoppedByFirmware { txn_id: u64 },
    ConnectConf { resp: ConnectConfirm },
    RoamConf { conf: RoamConfirm },
    RoamStartInd { ind: RoamStartIndication },
    RoamResultInd { ind: RoamResultIndication },
    AuthenticateInd { ind: AuthenticateIndication },
    DeauthenticateConf { resp: DeauthenticateConfirm },
    DeauthenticateInd { ind: DeauthenticateIndication },
    AssociateInd { ind: AssociateIndication },
    DisassociateConf { resp: DisassociateConfirm },
    DisassociateInd { ind: DisassociateIndication },
    StartConf { resp: StartConfirm },
    StopConf { resp: StopConfirm },
    SetKeysConf { conf: SetKeysConfirm },
    EapolConf { resp: EapolConfirm },
    SignalReport { ind: fidl_fuchsia_wlan_internal::SignalReportIndication },
    EapolInd { ind: EapolIndication },
    RelayCapturedFrame { result: CapturedFrameResult },
    OnChannelSwitched { info: fidl_fuchsia_wlan_internal::ChannelSwitchInfo },
    OnPmkAvailable { info: PmkInfo },
    OnSaeHandshakeInd { ind: SaeHandshakeIndication },
    OnSaeFrameRx { frame: SaeFrame },
    OnWmmStatusResp { status: i32, resp: fidl_fuchsia_wlan_internal::WmmStatusResponse },
}

impl MlmeEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_scan_result(self) -> Option<ScanResult> {
        if let MlmeEvent::OnScanResult { result } = self { Some((result)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_scan_end(self) -> Option<ScanEnd> {
        if let MlmeEvent::OnScanEnd { end } = self { Some((end)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_scheduled_scan_matches_available(self) -> Option<u64> {
        if let MlmeEvent::OnScheduledScanMatchesAvailable { txn_id } = self {
            Some((txn_id))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_scheduled_scan_stopped_by_firmware(self) -> Option<u64> {
        if let MlmeEvent::OnScheduledScanStoppedByFirmware { txn_id } = self {
            Some((txn_id))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_conf(self) -> Option<ConnectConfirm> {
        if let MlmeEvent::ConnectConf { resp } = self { Some((resp)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_roam_conf(self) -> Option<RoamConfirm> {
        if let MlmeEvent::RoamConf { conf } = self { Some((conf)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_roam_start_ind(self) -> Option<RoamStartIndication> {
        if let MlmeEvent::RoamStartInd { ind } = self { Some((ind)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_roam_result_ind(self) -> Option<RoamResultIndication> {
        if let MlmeEvent::RoamResultInd { ind } = self { Some((ind)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_authenticate_ind(self) -> Option<AuthenticateIndication> {
        if let MlmeEvent::AuthenticateInd { ind } = self { Some((ind)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_deauthenticate_conf(self) -> Option<DeauthenticateConfirm> {
        if let MlmeEvent::DeauthenticateConf { resp } = self { Some((resp)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_deauthenticate_ind(self) -> Option<DeauthenticateIndication> {
        if let MlmeEvent::DeauthenticateInd { ind } = self { Some((ind)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_associate_ind(self) -> Option<AssociateIndication> {
        if let MlmeEvent::AssociateInd { ind } = self { Some((ind)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_disassociate_conf(self) -> Option<DisassociateConfirm> {
        if let MlmeEvent::DisassociateConf { resp } = self { Some((resp)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_disassociate_ind(self) -> Option<DisassociateIndication> {
        if let MlmeEvent::DisassociateInd { ind } = self { Some((ind)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_start_conf(self) -> Option<StartConfirm> {
        if let MlmeEvent::StartConf { resp } = self { Some((resp)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_conf(self) -> Option<StopConfirm> {
        if let MlmeEvent::StopConf { resp } = self { Some((resp)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_set_keys_conf(self) -> Option<SetKeysConfirm> {
        if let MlmeEvent::SetKeysConf { conf } = self { Some((conf)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_eapol_conf(self) -> Option<EapolConfirm> {
        if let MlmeEvent::EapolConf { resp } = self { Some((resp)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_signal_report(self) -> Option<fidl_fuchsia_wlan_internal::SignalReportIndication> {
        if let MlmeEvent::SignalReport { ind } = self { Some((ind)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_eapol_ind(self) -> Option<EapolIndication> {
        if let MlmeEvent::EapolInd { ind } = self { Some((ind)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_relay_captured_frame(self) -> Option<CapturedFrameResult> {
        if let MlmeEvent::RelayCapturedFrame { result } = self { Some((result)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_channel_switched(self) -> Option<fidl_fuchsia_wlan_internal::ChannelSwitchInfo> {
        if let MlmeEvent::OnChannelSwitched { info } = self { Some((info)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_pmk_available(self) -> Option<PmkInfo> {
        if let MlmeEvent::OnPmkAvailable { info } = self { Some((info)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_sae_handshake_ind(self) -> Option<SaeHandshakeIndication> {
        if let MlmeEvent::OnSaeHandshakeInd { ind } = self { Some((ind)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_sae_frame_rx(self) -> Option<SaeFrame> {
        if let MlmeEvent::OnSaeFrameRx { frame } = self { Some((frame)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_wmm_status_resp(
        self,
    ) -> Option<(i32, fidl_fuchsia_wlan_internal::WmmStatusResponse)> {
        if let MlmeEvent::OnWmmStatusResp { status, resp } = self {
            Some((status, resp))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`MlmeEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<MlmeEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            0x681af7466a75074d => {
                let mut out = fidl::new_empty!(
                    MlmeOnScanResultRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeOnScanResultRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::OnScanResult { result: out.result }))
            }
            0x7f2702d253e7ca59 => {
                let mut out = fidl::new_empty!(
                    MlmeOnScanEndRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeOnScanEndRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::OnScanEnd { end: out.end }))
            }
            0x3d915df5108ec4e1 => {
                let mut out = fidl::new_empty!(
                    MlmeOnScheduledScanMatchesAvailableRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeOnScheduledScanMatchesAvailableRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::OnScheduledScanMatchesAvailable { txn_id: out.txn_id }))
            }
            0x4c2cb4b145163fd0 => {
                let mut out = fidl::new_empty!(
                    MlmeOnScheduledScanStoppedByFirmwareRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeOnScheduledScanStoppedByFirmwareRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::OnScheduledScanStoppedByFirmware { txn_id: out.txn_id }))
            }
            0x77b27623279b981e => {
                let mut out = fidl::new_empty!(
                    MlmeConnectConfRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeConnectConfRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::ConnectConf { resp: out.resp }))
            }
            0x3f608034faa054bc => {
                let mut out = fidl::new_empty!(
                    MlmeRoamConfRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeRoamConfRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::RoamConf { conf: out.conf }))
            }
            0x270a1ec78672d094 => {
                let mut out = fidl::new_empty!(
                    MlmeRoamStartIndRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeRoamStartIndRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::RoamStartInd { ind: out.ind }))
            }
            0x26d074364fc84865 => {
                let mut out = fidl::new_empty!(
                    MlmeRoamResultIndRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeRoamResultIndRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::RoamResultInd { ind: out.ind }))
            }
            0x460f49ae891adbe9 => {
                let mut out = fidl::new_empty!(
                    MlmeAuthenticateIndRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeAuthenticateIndRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::AuthenticateInd { ind: out.ind }))
            }
            0x3b44debc21b88c8c => {
                let mut out = fidl::new_empty!(
                    MlmeDeauthenticateConfRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeDeauthenticateConfRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::DeauthenticateConf { resp: out.resp }))
            }
            0x7ee0889b326da1d7 => {
                let mut out = fidl::new_empty!(
                    MlmeDeauthenticateIndRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeDeauthenticateIndRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::DeauthenticateInd { ind: out.ind }))
            }
            0x6a86f20e3063dd63 => {
                let mut out = fidl::new_empty!(
                    MlmeAssociateIndRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeAssociateIndRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::AssociateInd { ind: out.ind }))
            }
            0x61345fbce732a28d => {
                let mut out = fidl::new_empty!(
                    MlmeDisassociateConfRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeDisassociateConfRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::DisassociateConf { resp: out.resp }))
            }
            0x77ac0ebf387c1f35 => {
                let mut out = fidl::new_empty!(
                    MlmeDisassociateIndRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeDisassociateIndRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::DisassociateInd { ind: out.ind }))
            }
            0x15ea6cdf3b8382b3 => {
                let mut out = fidl::new_empty!(
                    MlmeStartConfRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeStartConfRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::StartConf { resp: out.resp }))
            }
            0x50b426ef4a84a2df => {
                let mut out = fidl::new_empty!(
                    MlmeStopConfRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeStopConfRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::StopConf { resp: out.resp }))
            }
            0x5bafb3a8d4039380 => {
                let mut out = fidl::new_empty!(
                    MlmeSetKeysConfRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeSetKeysConfRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::SetKeysConf { conf: out.conf }))
            }
            0x6ffa21f4ee73ce64 => {
                let mut out = fidl::new_empty!(
                    MlmeEapolConfRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeEapolConfRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::EapolConf { resp: out.resp }))
            }
            0x48f32a876aa53d8f => {
                let mut out = fidl::new_empty!(
                    MlmeSignalReportRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeSignalReportRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::SignalReport { ind: out.ind }))
            }
            0x7038dca46a3142fc => {
                let mut out = fidl::new_empty!(
                    MlmeEapolIndRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeEapolIndRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::EapolInd { ind: out.ind }))
            }
            0x6f00a6f3cff9b1f5 => {
                let mut out = fidl::new_empty!(
                    MlmeRelayCapturedFrameRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeRelayCapturedFrameRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::RelayCapturedFrame { result: out.result }))
            }
            0x581750594e4c0c1 => {
                let mut out = fidl::new_empty!(
                    MlmeOnChannelSwitchedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeOnChannelSwitchedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::OnChannelSwitched { info: out.info }))
            }
            0x1314fc2c79643f90 => {
                let mut out = fidl::new_empty!(
                    MlmeOnPmkAvailableRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeOnPmkAvailableRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::OnPmkAvailable { info: out.info }))
            }
            0x6308b10e18986d7e => {
                let mut out = fidl::new_empty!(
                    MlmeOnSaeHandshakeIndRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeOnSaeHandshakeIndRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::OnSaeHandshakeInd { ind: out.ind }))
            }
            0x4ebf51c86ef5f3cd => {
                let mut out = fidl::new_empty!(
                    MlmeOnSaeFrameRxRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeOnSaeFrameRxRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::OnSaeFrameRx { frame: out.frame }))
            }
            0x53f056b432e7b5cb => {
                let mut out = fidl::new_empty!(
                    MlmeOnWmmStatusRespRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeOnWmmStatusRespRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((MlmeEvent::OnWmmStatusResp { status: out.status, resp: out.resp }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <MlmeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.wlan.mlme/MLME.
pub struct MlmeRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for MlmeRequestStream {}

impl futures::stream::FusedStream for MlmeRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for MlmeRequestStream {
    type Protocol = MlmeMarker;
    type ControlHandle = MlmeControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        MlmeControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for MlmeRequestStream {
    type Item = Result<MlmeRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled MlmeRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x342cc5ec6a957479 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeStartScanRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeStartScanRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::StartScan { req: req.req, control_handle })
                    }
                    0x7fff163af4620212 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeStartScheduledScanRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeStartScheduledScanRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::StartScheduledScan {
                            txn_id: req.txn_id,
                            req: req.req,

                            responder: MlmeStartScheduledScanResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5fbc466f3daa4dd9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeStopScheduledScanRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeStopScheduledScanRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::StopScheduledScan {
                            txn_id: req.txn_id,

                            responder: MlmeStopScheduledScanResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ecc6a7fe7f9fcff => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::GetScheduledScanEnabled {
                            responder: MlmeGetScheduledScanEnabledResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x31153dc85f8f64c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeConnectReqRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeConnectReqRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::ConnectReq { req: req.req, control_handle })
                    }
                    0x74e0f1bd758b6b78 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeReconnectReqRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeReconnectReqRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::ReconnectReq { req: req.req, control_handle })
                    }
                    0x3ba163eadf7dba45 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeRoamReqRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeRoamReqRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::RoamReq { req: req.req, control_handle })
                    }
                    0x26108aade2fdd2f4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeAuthenticateRespRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeAuthenticateRespRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::AuthenticateResp { resp: req.resp, control_handle })
                    }
                    0x228983b200de5d12 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeDeauthenticateReqRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeDeauthenticateReqRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::DeauthenticateReq { req: req.req, control_handle })
                    }
                    0x70244dbd652ed6d9 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeAssociateRespRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeAssociateRespRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::AssociateResp { resp: req.resp, control_handle })
                    }
                    0x5765807f1387d764 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeDisassociateReqRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeDisassociateReqRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::DisassociateReq { req: req.req, control_handle })
                    }
                    0x780b98c58a286b9f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeResetReqRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeResetReqRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::ResetReq { req: req.req, control_handle })
                    }
                    0x5d95885f8053654 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeStartReqRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeStartReqRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::StartReq { req: req.req, control_handle })
                    }
                    0x27b9a2ab04a2c79f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeStopReqRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeStopReqRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::StopReq { req: req.req, control_handle })
                    }
                    0x6b30a07fd3a11a79 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeSetKeysReqRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeSetKeysReqRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::SetKeysReq { req: req.req, control_handle })
                    }
                    0x1e3524d20d190c8f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeDeleteKeysReqRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeDeleteKeysReqRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::DeleteKeysReq { req: req.req, control_handle })
                    }
                    0xc3c096924704d4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeEapolReqRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeEapolReqRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::EapolReq { req: req.req, control_handle })
                    }
                    0x4e47065668890c8d => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeSetControlledPortRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeSetControlledPortRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::SetControlledPort { req: req.req, control_handle })
                    }
                    0x6ee3e7f63f2b7bc0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::QueryDeviceInfo {
                            responder: MlmeQueryDeviceInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1598879b70332c99 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::QueryTelemetrySupport {
                            responder: MlmeQueryTelemetrySupportResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xede1a8342d1b211 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::GetIfaceStats {
                            responder: MlmeGetIfaceStatsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1979c9d3449f8675 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::GetIfaceHistogramStats {
                            responder: MlmeGetIfaceHistogramStatsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7e47e7ebe92acec9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::GetSignalReport {
                            responder: MlmeGetSignalReportResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4ac5d1e66fe1ffd5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::ListMinstrelPeers {
                            responder: MlmeListMinstrelPeersResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2f688b1245323f4b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeGetMinstrelStatsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeGetMinstrelStatsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::GetMinstrelStats {
                            req: req.req,

                            responder: MlmeGetMinstrelStatsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x23b369ed5749ee69 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeStartCaptureFramesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeStartCaptureFramesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::StartCaptureFrames {
                            req: req.req,

                            responder: MlmeStartCaptureFramesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2f1aebbc68bf7c54 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::StopCaptureFrames { control_handle })
                    }
                    0x28477bd2f7a5ab0c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeSaeHandshakeRespRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeSaeHandshakeRespRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::SaeHandshakeResp { resp: req.resp, control_handle })
                    }
                    0x7700c0d536733d8c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeSaeFrameTxRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeSaeFrameTxRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::SaeFrameTx { frame: req.frame, control_handle })
                    }
                    0xef4851f6088fede => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::WmmStatusReq { control_handle })
                    }
                    0x7aea59787cfd385a => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeFinalizeAssociationReqRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeFinalizeAssociationReqRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::FinalizeAssociationReq {
                            negotiated_capabilities: req.negotiated_capabilities,

                            control_handle,
                        })
                    }
                    0x476999f9bb27afe1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeSetMacAddressRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeSetMacAddressRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::SetMacAddress {
                            mac_addr: req.mac_addr,

                            responder: MlmeSetMacAddressResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x267565b4916c825b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeInstallApfPacketFilterRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeInstallApfPacketFilterRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::InstallApfPacketFilter {
                            program: req.program,

                            responder: MlmeInstallApfPacketFilterResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6040d744f1b2cb61 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::ReadApfPacketFilterData {
                            responder: MlmeReadApfPacketFilterDataResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6d99bdca77076aea => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MlmeSetApfPacketFilterEnabledRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MlmeSetApfPacketFilterEnabledRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::SetApfPacketFilterEnabled {
                            enabled: req.enabled,

                            responder: MlmeSetApfPacketFilterEnabledResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1df408bc154be1e4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MlmeControlHandle { inner: this.inner.clone() };
                        Ok(MlmeRequest::GetApfPacketFilterEnabled {
                            responder: MlmeGetApfPacketFilterEnabledResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name: <MlmeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum MlmeRequest {
    StartScan {
        req: ScanRequest,
        control_handle: MlmeControlHandle,
    },
    /// Starts scheduled scanning.
    StartScheduledScan {
        txn_id: u64,
        req: fidl_fuchsia_wlan_common::ScheduledScanRequest,
        responder: MlmeStartScheduledScanResponder,
    },
    /// Stops scheduled scanning.
    StopScheduledScan {
        txn_id: u64,
        responder: MlmeStopScheduledScanResponder,
    },
    /// Returns the transaction IDs of any currently active scheduled scans.
    GetScheduledScanEnabled {
        responder: MlmeGetScheduledScanEnabledResponder,
    },
    ConnectReq {
        req: ConnectRequest,
        control_handle: MlmeControlHandle,
    },
    ReconnectReq {
        req: ReconnectRequest,
        control_handle: MlmeControlHandle,
    },
    /// Initiate a roam attempt (SME-initiated).
    RoamReq {
        req: RoamRequest,
        control_handle: MlmeControlHandle,
    },
    AuthenticateResp {
        resp: AuthenticateResponse,
        control_handle: MlmeControlHandle,
    },
    DeauthenticateReq {
        req: DeauthenticateRequest,
        control_handle: MlmeControlHandle,
    },
    AssociateResp {
        resp: AssociateResponse,
        control_handle: MlmeControlHandle,
    },
    DisassociateReq {
        req: DisassociateRequest,
        control_handle: MlmeControlHandle,
    },
    ResetReq {
        req: ResetRequest,
        control_handle: MlmeControlHandle,
    },
    StartReq {
        req: StartRequest,
        control_handle: MlmeControlHandle,
    },
    StopReq {
        req: StopRequest,
        control_handle: MlmeControlHandle,
    },
    SetKeysReq {
        req: SetKeysRequest,
        control_handle: MlmeControlHandle,
    },
    DeleteKeysReq {
        req: DeleteKeysRequest,
        control_handle: MlmeControlHandle,
    },
    EapolReq {
        req: EapolRequest,
        control_handle: MlmeControlHandle,
    },
    SetControlledPort {
        req: SetControlledPortRequest,
        control_handle: MlmeControlHandle,
    },
    QueryDeviceInfo {
        responder: MlmeQueryDeviceInfoResponder,
    },
    QueryTelemetrySupport {
        responder: MlmeQueryTelemetrySupportResponder,
    },
    GetIfaceStats {
        responder: MlmeGetIfaceStatsResponder,
    },
    GetIfaceHistogramStats {
        responder: MlmeGetIfaceHistogramStatsResponder,
    },
    GetSignalReport {
        responder: MlmeGetSignalReportResponder,
    },
    ListMinstrelPeers {
        responder: MlmeListMinstrelPeersResponder,
    },
    GetMinstrelStats {
        req: MinstrelStatsRequest,
        responder: MlmeGetMinstrelStatsResponder,
    },
    StartCaptureFrames {
        req: StartCaptureFramesRequest,
        responder: MlmeStartCaptureFramesResponder,
    },
    StopCaptureFrames {
        control_handle: MlmeControlHandle,
    },
    /// Notifies that SAE authentication is completed.
    SaeHandshakeResp {
        resp: SaeHandshakeResponse,
        control_handle: MlmeControlHandle,
    },
    /// Transmits SAE frame (if SME is managing SAE authentication).
    SaeFrameTx {
        frame: SaeFrame,
        control_handle: MlmeControlHandle,
    },
    WmmStatusReq {
        control_handle: MlmeControlHandle,
    },
    FinalizeAssociationReq {
        negotiated_capabilities: NegotiatedCapabilities,
        control_handle: MlmeControlHandle,
    },
    SetMacAddress {
        mac_addr: [u8; 6],
        responder: MlmeSetMacAddressResponder,
    },
    InstallApfPacketFilter {
        program: Vec<u8>,
        responder: MlmeInstallApfPacketFilterResponder,
    },
    ReadApfPacketFilterData {
        responder: MlmeReadApfPacketFilterDataResponder,
    },
    SetApfPacketFilterEnabled {
        enabled: bool,
        responder: MlmeSetApfPacketFilterEnabledResponder,
    },
    GetApfPacketFilterEnabled {
        responder: MlmeGetApfPacketFilterEnabledResponder,
    },
}

impl MlmeRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_start_scan(self) -> Option<(ScanRequest, MlmeControlHandle)> {
        if let MlmeRequest::StartScan { req, control_handle } = self {
            Some((req, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start_scheduled_scan(
        self,
    ) -> Option<(
        u64,
        fidl_fuchsia_wlan_common::ScheduledScanRequest,
        MlmeStartScheduledScanResponder,
    )> {
        if let MlmeRequest::StartScheduledScan { txn_id, req, responder } = self {
            Some((txn_id, req, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_scheduled_scan(self) -> Option<(u64, MlmeStopScheduledScanResponder)> {
        if let MlmeRequest::StopScheduledScan { txn_id, responder } = self {
            Some((txn_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_scheduled_scan_enabled(self) -> Option<(MlmeGetScheduledScanEnabledResponder)> {
        if let MlmeRequest::GetScheduledScanEnabled { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_req(self) -> Option<(ConnectRequest, MlmeControlHandle)> {
        if let MlmeRequest::ConnectReq { req, control_handle } = self {
            Some((req, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reconnect_req(self) -> Option<(ReconnectRequest, MlmeControlHandle)> {
        if let MlmeRequest::ReconnectReq { req, control_handle } = self {
            Some((req, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_roam_req(self) -> Option<(RoamRequest, MlmeControlHandle)> {
        if let MlmeRequest::RoamReq { req, control_handle } = self {
            Some((req, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_authenticate_resp(self) -> Option<(AuthenticateResponse, MlmeControlHandle)> {
        if let MlmeRequest::AuthenticateResp { resp, control_handle } = self {
            Some((resp, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_deauthenticate_req(self) -> Option<(DeauthenticateRequest, MlmeControlHandle)> {
        if let MlmeRequest::DeauthenticateReq { req, control_handle } = self {
            Some((req, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_associate_resp(self) -> Option<(AssociateResponse, MlmeControlHandle)> {
        if let MlmeRequest::AssociateResp { resp, control_handle } = self {
            Some((resp, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_disassociate_req(self) -> Option<(DisassociateRequest, MlmeControlHandle)> {
        if let MlmeRequest::DisassociateReq { req, control_handle } = self {
            Some((req, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reset_req(self) -> Option<(ResetRequest, MlmeControlHandle)> {
        if let MlmeRequest::ResetReq { req, control_handle } = self {
            Some((req, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start_req(self) -> Option<(StartRequest, MlmeControlHandle)> {
        if let MlmeRequest::StartReq { req, control_handle } = self {
            Some((req, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_req(self) -> Option<(StopRequest, MlmeControlHandle)> {
        if let MlmeRequest::StopReq { req, control_handle } = self {
            Some((req, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_keys_req(self) -> Option<(SetKeysRequest, MlmeControlHandle)> {
        if let MlmeRequest::SetKeysReq { req, control_handle } = self {
            Some((req, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_delete_keys_req(self) -> Option<(DeleteKeysRequest, MlmeControlHandle)> {
        if let MlmeRequest::DeleteKeysReq { req, control_handle } = self {
            Some((req, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_eapol_req(self) -> Option<(EapolRequest, MlmeControlHandle)> {
        if let MlmeRequest::EapolReq { req, control_handle } = self {
            Some((req, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_controlled_port(self) -> Option<(SetControlledPortRequest, MlmeControlHandle)> {
        if let MlmeRequest::SetControlledPort { req, control_handle } = self {
            Some((req, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_device_info(self) -> Option<(MlmeQueryDeviceInfoResponder)> {
        if let MlmeRequest::QueryDeviceInfo { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_telemetry_support(self) -> Option<(MlmeQueryTelemetrySupportResponder)> {
        if let MlmeRequest::QueryTelemetrySupport { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_iface_stats(self) -> Option<(MlmeGetIfaceStatsResponder)> {
        if let MlmeRequest::GetIfaceStats { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_iface_histogram_stats(self) -> Option<(MlmeGetIfaceHistogramStatsResponder)> {
        if let MlmeRequest::GetIfaceHistogramStats { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_signal_report(self) -> Option<(MlmeGetSignalReportResponder)> {
        if let MlmeRequest::GetSignalReport { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_list_minstrel_peers(self) -> Option<(MlmeListMinstrelPeersResponder)> {
        if let MlmeRequest::ListMinstrelPeers { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_minstrel_stats(
        self,
    ) -> Option<(MinstrelStatsRequest, MlmeGetMinstrelStatsResponder)> {
        if let MlmeRequest::GetMinstrelStats { req, responder } = self {
            Some((req, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start_capture_frames(
        self,
    ) -> Option<(StartCaptureFramesRequest, MlmeStartCaptureFramesResponder)> {
        if let MlmeRequest::StartCaptureFrames { req, responder } = self {
            Some((req, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_capture_frames(self) -> Option<(MlmeControlHandle)> {
        if let MlmeRequest::StopCaptureFrames { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_sae_handshake_resp(self) -> Option<(SaeHandshakeResponse, MlmeControlHandle)> {
        if let MlmeRequest::SaeHandshakeResp { resp, control_handle } = self {
            Some((resp, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_sae_frame_tx(self) -> Option<(SaeFrame, MlmeControlHandle)> {
        if let MlmeRequest::SaeFrameTx { frame, control_handle } = self {
            Some((frame, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_wmm_status_req(self) -> Option<(MlmeControlHandle)> {
        if let MlmeRequest::WmmStatusReq { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_finalize_association_req(
        self,
    ) -> Option<(NegotiatedCapabilities, MlmeControlHandle)> {
        if let MlmeRequest::FinalizeAssociationReq { negotiated_capabilities, control_handle } =
            self
        {
            Some((negotiated_capabilities, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_mac_address(self) -> Option<([u8; 6], MlmeSetMacAddressResponder)> {
        if let MlmeRequest::SetMacAddress { mac_addr, responder } = self {
            Some((mac_addr, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_install_apf_packet_filter(
        self,
    ) -> Option<(Vec<u8>, MlmeInstallApfPacketFilterResponder)> {
        if let MlmeRequest::InstallApfPacketFilter { program, responder } = self {
            Some((program, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_apf_packet_filter_data(
        self,
    ) -> Option<(MlmeReadApfPacketFilterDataResponder)> {
        if let MlmeRequest::ReadApfPacketFilterData { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_apf_packet_filter_enabled(
        self,
    ) -> Option<(bool, MlmeSetApfPacketFilterEnabledResponder)> {
        if let MlmeRequest::SetApfPacketFilterEnabled { enabled, responder } = self {
            Some((enabled, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_apf_packet_filter_enabled(
        self,
    ) -> Option<(MlmeGetApfPacketFilterEnabledResponder)> {
        if let MlmeRequest::GetApfPacketFilterEnabled { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            MlmeRequest::StartScan { .. } => "start_scan",
            MlmeRequest::StartScheduledScan { .. } => "start_scheduled_scan",
            MlmeRequest::StopScheduledScan { .. } => "stop_scheduled_scan",
            MlmeRequest::GetScheduledScanEnabled { .. } => "get_scheduled_scan_enabled",
            MlmeRequest::ConnectReq { .. } => "connect_req",
            MlmeRequest::ReconnectReq { .. } => "reconnect_req",
            MlmeRequest::RoamReq { .. } => "roam_req",
            MlmeRequest::AuthenticateResp { .. } => "authenticate_resp",
            MlmeRequest::DeauthenticateReq { .. } => "deauthenticate_req",
            MlmeRequest::AssociateResp { .. } => "associate_resp",
            MlmeRequest::DisassociateReq { .. } => "disassociate_req",
            MlmeRequest::ResetReq { .. } => "reset_req",
            MlmeRequest::StartReq { .. } => "start_req",
            MlmeRequest::StopReq { .. } => "stop_req",
            MlmeRequest::SetKeysReq { .. } => "set_keys_req",
            MlmeRequest::DeleteKeysReq { .. } => "delete_keys_req",
            MlmeRequest::EapolReq { .. } => "eapol_req",
            MlmeRequest::SetControlledPort { .. } => "set_controlled_port",
            MlmeRequest::QueryDeviceInfo { .. } => "query_device_info",
            MlmeRequest::QueryTelemetrySupport { .. } => "query_telemetry_support",
            MlmeRequest::GetIfaceStats { .. } => "get_iface_stats",
            MlmeRequest::GetIfaceHistogramStats { .. } => "get_iface_histogram_stats",
            MlmeRequest::GetSignalReport { .. } => "get_signal_report",
            MlmeRequest::ListMinstrelPeers { .. } => "list_minstrel_peers",
            MlmeRequest::GetMinstrelStats { .. } => "get_minstrel_stats",
            MlmeRequest::StartCaptureFrames { .. } => "start_capture_frames",
            MlmeRequest::StopCaptureFrames { .. } => "stop_capture_frames",
            MlmeRequest::SaeHandshakeResp { .. } => "sae_handshake_resp",
            MlmeRequest::SaeFrameTx { .. } => "sae_frame_tx",
            MlmeRequest::WmmStatusReq { .. } => "wmm_status_req",
            MlmeRequest::FinalizeAssociationReq { .. } => "finalize_association_req",
            MlmeRequest::SetMacAddress { .. } => "set_mac_address",
            MlmeRequest::InstallApfPacketFilter { .. } => "install_apf_packet_filter",
            MlmeRequest::ReadApfPacketFilterData { .. } => "read_apf_packet_filter_data",
            MlmeRequest::SetApfPacketFilterEnabled { .. } => "set_apf_packet_filter_enabled",
            MlmeRequest::GetApfPacketFilterEnabled { .. } => "get_apf_packet_filter_enabled",
        }
    }
}

#[derive(Debug, Clone)]
pub struct MlmeControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for MlmeControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl MlmeControlHandle {
    pub fn send_on_scan_result(&self, mut result: &ScanResult) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeOnScanResultRequest>(
            (result,),
            0,
            0x681af7466a75074d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_scan_end(&self, mut end: &ScanEnd) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeOnScanEndRequest>(
            (end,),
            0,
            0x7f2702d253e7ca59,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_scheduled_scan_matches_available(
        &self,
        mut txn_id: u64,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeOnScheduledScanMatchesAvailableRequest>(
            (txn_id,),
            0,
            0x3d915df5108ec4e1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_scheduled_scan_stopped_by_firmware(
        &self,
        mut txn_id: u64,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeOnScheduledScanStoppedByFirmwareRequest>(
            (txn_id,),
            0,
            0x4c2cb4b145163fd0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_connect_conf(&self, mut resp: &ConnectConfirm) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeConnectConfRequest>(
            (resp,),
            0,
            0x77b27623279b981e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_roam_conf(&self, mut conf: &RoamConfirm) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeRoamConfRequest>(
            (conf,),
            0,
            0x3f608034faa054bc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_roam_start_ind(&self, mut ind: &RoamStartIndication) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeRoamStartIndRequest>(
            (ind,),
            0,
            0x270a1ec78672d094,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_roam_result_ind(&self, mut ind: &RoamResultIndication) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeRoamResultIndRequest>(
            (ind,),
            0,
            0x26d074364fc84865,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_authenticate_ind(
        &self,
        mut ind: &AuthenticateIndication,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeAuthenticateIndRequest>(
            (ind,),
            0,
            0x460f49ae891adbe9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_deauthenticate_conf(
        &self,
        mut resp: &DeauthenticateConfirm,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeDeauthenticateConfRequest>(
            (resp,),
            0,
            0x3b44debc21b88c8c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_deauthenticate_ind(
        &self,
        mut ind: &DeauthenticateIndication,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeDeauthenticateIndRequest>(
            (ind,),
            0,
            0x7ee0889b326da1d7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_associate_ind(&self, mut ind: &AssociateIndication) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeAssociateIndRequest>(
            (ind,),
            0,
            0x6a86f20e3063dd63,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_disassociate_conf(
        &self,
        mut resp: &DisassociateConfirm,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeDisassociateConfRequest>(
            (resp,),
            0,
            0x61345fbce732a28d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_disassociate_ind(
        &self,
        mut ind: &DisassociateIndication,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeDisassociateIndRequest>(
            (ind,),
            0,
            0x77ac0ebf387c1f35,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_start_conf(&self, mut resp: &StartConfirm) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeStartConfRequest>(
            (resp,),
            0,
            0x15ea6cdf3b8382b3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_stop_conf(&self, mut resp: &StopConfirm) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeStopConfRequest>(
            (resp,),
            0,
            0x50b426ef4a84a2df,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_set_keys_conf(&self, mut conf: &SetKeysConfirm) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeSetKeysConfRequest>(
            (conf,),
            0,
            0x5bafb3a8d4039380,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_eapol_conf(&self, mut resp: &EapolConfirm) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeEapolConfRequest>(
            (resp,),
            0,
            0x6ffa21f4ee73ce64,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_signal_report(
        &self,
        mut ind: &fidl_fuchsia_wlan_internal::SignalReportIndication,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeSignalReportRequest>(
            (ind,),
            0,
            0x48f32a876aa53d8f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_eapol_ind(&self, mut ind: &EapolIndication) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeEapolIndRequest>(
            (ind,),
            0,
            0x7038dca46a3142fc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_relay_captured_frame(
        &self,
        mut result: &CapturedFrameResult,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeRelayCapturedFrameRequest>(
            (result,),
            0,
            0x6f00a6f3cff9b1f5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_channel_switched(
        &self,
        mut info: &fidl_fuchsia_wlan_internal::ChannelSwitchInfo,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeOnChannelSwitchedRequest>(
            (info,),
            0,
            0x581750594e4c0c1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_pmk_available(&self, mut info: &PmkInfo) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeOnPmkAvailableRequest>(
            (info,),
            0,
            0x1314fc2c79643f90,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_sae_handshake_ind(
        &self,
        mut ind: &SaeHandshakeIndication,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeOnSaeHandshakeIndRequest>(
            (ind,),
            0,
            0x6308b10e18986d7e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_sae_frame_rx(&self, mut frame: &SaeFrame) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeOnSaeFrameRxRequest>(
            (frame,),
            0,
            0x4ebf51c86ef5f3cd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_wmm_status_resp(
        &self,
        mut status: i32,
        mut resp: &fidl_fuchsia_wlan_internal::WmmStatusResponse,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<MlmeOnWmmStatusRespRequest>(
            (status, resp),
            0,
            0x53f056b432e7b5cb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeStartScheduledScanResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeStartScheduledScanResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeStartScheduledScanResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeStartScheduledScanResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x7fff163af4620212,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeStopScheduledScanResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeStopScheduledScanResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeStopScheduledScanResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeStopScheduledScanResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x5fbc466f3daa4dd9,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeGetScheduledScanEnabledResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeGetScheduledScanEnabledResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeGetScheduledScanEnabledResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeGetScheduledScanEnabledResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<&[u64], i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&[u64], i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<&[u64], i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            MlmeGetScheduledScanEnabledResponse,
            i32,
        >>(
            result.map(|active_txn_ids| (active_txn_ids,)),
            self.tx_id,
            0x1ecc6a7fe7f9fcff,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeQueryDeviceInfoResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeQueryDeviceInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeQueryDeviceInfoResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeQueryDeviceInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut info: &DeviceInfo) -> Result<(), fidl::Error> {
        let _result = self.send_raw(info);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut info: &DeviceInfo) -> Result<(), fidl::Error> {
        let _result = self.send_raw(info);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut info: &DeviceInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<MlmeQueryDeviceInfoResponse>(
            (info,),
            self.tx_id,
            0x6ee3e7f63f2b7bc0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeQueryTelemetrySupportResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeQueryTelemetrySupportResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeQueryTelemetrySupportResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeQueryTelemetrySupportResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_wlan_stats::TelemetrySupport, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_wlan_stats::TelemetrySupport, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_wlan_stats::TelemetrySupport, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<MlmeQueryTelemetrySupportResponse, i32>>(
                result.map(|resp| (resp,)),
                self.tx_id,
                0x1598879b70332c99,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeGetIfaceStatsResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeGetIfaceStatsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeGetIfaceStatsResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeGetIfaceStatsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut resp: &GetIfaceStatsResponse) -> Result<(), fidl::Error> {
        let _result = self.send_raw(resp);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut resp: &GetIfaceStatsResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(resp);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut resp: &GetIfaceStatsResponse) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<MlmeGetIfaceStatsResponse>(
            (resp,),
            self.tx_id,
            0xede1a8342d1b211,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeGetIfaceHistogramStatsResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeGetIfaceHistogramStatsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeGetIfaceHistogramStatsResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeGetIfaceHistogramStatsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut resp: &GetIfaceHistogramStatsResponse) -> Result<(), fidl::Error> {
        let _result = self.send_raw(resp);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut resp: &GetIfaceHistogramStatsResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(resp);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut resp: &GetIfaceHistogramStatsResponse) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<MlmeGetIfaceHistogramStatsResponse>(
            (resp,),
            self.tx_id,
            0x1979c9d3449f8675,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeGetSignalReportResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeGetSignalReportResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeGetSignalReportResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeGetSignalReportResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_wlan_stats::SignalReport, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_wlan_stats::SignalReport, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_wlan_stats::SignalReport, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<MlmeGetSignalReportResponse, i32>>(
                result.map(|resp| (resp,)),
                self.tx_id,
                0x7e47e7ebe92acec9,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeListMinstrelPeersResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeListMinstrelPeersResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeListMinstrelPeersResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeListMinstrelPeersResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut resp: &MinstrelListResponse) -> Result<(), fidl::Error> {
        let _result = self.send_raw(resp);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut resp: &MinstrelListResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(resp);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut resp: &MinstrelListResponse) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<MlmeListMinstrelPeersResponse>(
            (resp,),
            self.tx_id,
            0x4ac5d1e66fe1ffd5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeGetMinstrelStatsResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeGetMinstrelStatsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeGetMinstrelStatsResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeGetMinstrelStatsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut resp: &MinstrelStatsResponse) -> Result<(), fidl::Error> {
        let _result = self.send_raw(resp);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut resp: &MinstrelStatsResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(resp);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut resp: &MinstrelStatsResponse) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<MlmeGetMinstrelStatsResponse>(
            (resp,),
            self.tx_id,
            0x2f688b1245323f4b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeStartCaptureFramesResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeStartCaptureFramesResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeStartCaptureFramesResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeStartCaptureFramesResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut resp: &StartCaptureFramesResponse) -> Result<(), fidl::Error> {
        let _result = self.send_raw(resp);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut resp: &StartCaptureFramesResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(resp);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut resp: &StartCaptureFramesResponse) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<MlmeStartCaptureFramesResponse>(
            (resp,),
            self.tx_id,
            0x23b369ed5749ee69,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeSetMacAddressResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeSetMacAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeSetMacAddressResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeSetMacAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x476999f9bb27afe1,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeInstallApfPacketFilterResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeInstallApfPacketFilterResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeInstallApfPacketFilterResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeInstallApfPacketFilterResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x267565b4916c825b,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeReadApfPacketFilterDataResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeReadApfPacketFilterDataResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeReadApfPacketFilterDataResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeReadApfPacketFilterDataResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<&[u8], i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&[u8], i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<&[u8], i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            MlmeReadApfPacketFilterDataResponse,
            i32,
        >>(
            result.map(|memory| (memory,)),
            self.tx_id,
            0x6040d744f1b2cb61,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeSetApfPacketFilterEnabledResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeSetApfPacketFilterEnabledResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeSetApfPacketFilterEnabledResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeSetApfPacketFilterEnabledResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x6d99bdca77076aea,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MlmeGetApfPacketFilterEnabledResponder {
    control_handle: std::mem::ManuallyDrop<MlmeControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MlmeControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MlmeGetApfPacketFilterEnabledResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MlmeGetApfPacketFilterEnabledResponder {
    type ControlHandle = MlmeControlHandle;

    fn control_handle(&self) -> &MlmeControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MlmeGetApfPacketFilterEnabledResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<bool, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<bool, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<bool, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            MlmeGetApfPacketFilterEnabledResponse,
            i32,
        >>(
            result.map(|enabled| (enabled,)),
            self.tx_id,
            0x1df408bc154be1e4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for ConnectorConnectRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ConnectorConnectRequest {
        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
        fidl::encoding::Encode<
            ConnectorConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ConnectorConnectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ConnectorConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ConnectorConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MlmeMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.request),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MlmeMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ConnectorConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ConnectorConnectRequest>(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 fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ConnectorConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                request: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MlmeMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MlmeMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.request,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }
}