fidl_fuchsia_wlan_softmac/

fidl_fuchsia_wlan_softmac.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_softmac_common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanSoftmacBridgeStartRequest {
    pub ifc_bridge: fidl::endpoints::ClientEnd<WlanSoftmacIfcBridgeMarker>,
    pub ethernet_tx: u64,
    pub wlan_rx: u64,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WlanSoftmacBridgeStartResponse {
    pub sme_channel: fidl::Channel,
}

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

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

impl fidl::endpoints::ProtocolMarker for EthernetRxMarker {
    type Proxy = EthernetRxProxy;
    type RequestStream = EthernetRxRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = EthernetRxSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) EthernetRx";
}
pub type EthernetRxTransferResult = Result<(), i32>;

pub trait EthernetRxProxyInterface: Send + Sync {
    type TransferResponseFut: std::future::Future<Output = Result<EthernetRxTransferResult, fidl::Error>>
        + Send;
    fn r#transfer(&self, payload: &EthernetRxTransferRequest) -> Self::TransferResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct EthernetRxSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for EthernetRxSynchronousProxy {
    type Proxy = EthernetRxProxy;
    type Protocol = EthernetRxMarker;

    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 EthernetRxSynchronousProxy {
    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<EthernetRxEvent, fidl::Error> {
        EthernetRxEvent::decode(self.client.wait_for_event::<EthernetRxMarker>(deadline)?)
    }

    pub fn r#transfer(
        &self,
        mut payload: &EthernetRxTransferRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EthernetRxTransferResult, fidl::Error> {
        let _response = self.client.send_query::<
            EthernetRxTransferRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            EthernetRxMarker,
        >(
            payload,
            0x199ff3498ef8a22a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for EthernetRxProxy {
    type Protocol = EthernetRxMarker;

    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 EthernetRxProxy {
    /// Create a new Proxy for fuchsia.wlan.softmac/EthernetRx.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <EthernetRxMarker 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) -> EthernetRxEventStream {
        EthernetRxEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#transfer(
        &self,
        mut payload: &EthernetRxTransferRequest,
    ) -> fidl::client::QueryResponseFut<
        EthernetRxTransferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        EthernetRxProxyInterface::r#transfer(self, payload)
    }
}

impl EthernetRxProxyInterface for EthernetRxProxy {
    type TransferResponseFut = fidl::client::QueryResponseFut<
        EthernetRxTransferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#transfer(&self, mut payload: &EthernetRxTransferRequest) -> Self::TransferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EthernetRxTransferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x199ff3498ef8a22a,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<EthernetRxTransferRequest, EthernetRxTransferResult>(
            payload,
            0x199ff3498ef8a22a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for EthernetRxEventStream {
    type Item = Result<EthernetRxEvent, 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(EthernetRxEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

impl EthernetRxEvent {
    /// Decodes a message buffer as a [`EthernetRxEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<EthernetRxEvent, 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: <EthernetRxMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for EthernetRxRequestStream {
    type Protocol = EthernetRxMarker;
    type ControlHandle = EthernetRxControlHandle;

    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 {
        EthernetRxControlHandle { 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 EthernetRxRequestStream {
    type Item = Result<EthernetRxRequest, 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 EthernetRxRequestStream 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 {
                    0x199ff3498ef8a22a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            EthernetRxTransferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EthernetRxTransferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = EthernetRxControlHandle { inner: this.inner.clone() };
                        Ok(EthernetRxRequest::Transfer {
                            payload: req,
                            responder: EthernetRxTransferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <EthernetRxMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol for sending an Ethernet frame from the bridged wlansoftmac
/// driver to the wlansoftmac driver.
///
/// # Experimental
///
/// This protocol is implemented as a foreign function interface (FFI)
/// between the wlansoftmac driver and the bridged driver solely to improve
/// the performance of processing data frames through the wlan-mlme library.
#[derive(Debug)]
pub enum EthernetRxRequest {
    Transfer { payload: EthernetRxTransferRequest, responder: EthernetRxTransferResponder },
}

impl EthernetRxRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_transfer(self) -> Option<(EthernetRxTransferRequest, EthernetRxTransferResponder)> {
        if let EthernetRxRequest::Transfer { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

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

impl EthernetRxControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 EthernetRxControlHandle {}

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

/// Set the the channel to be shutdown (see [`EthernetRxControlHandle::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 EthernetRxTransferResponder {
    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 EthernetRxTransferResponder {
    type ControlHandle = EthernetRxControlHandle;

    fn control_handle(&self) -> &EthernetRxControlHandle {
        &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 EthernetRxTransferResponder {
    /// 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,
                0x199ff3498ef8a22a,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

impl fidl::endpoints::ProtocolMarker for EthernetTxMarker {
    type Proxy = EthernetTxProxy;
    type RequestStream = EthernetTxRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = EthernetTxSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) EthernetTx";
}
pub type EthernetTxTransferResult = Result<(), i32>;

pub trait EthernetTxProxyInterface: Send + Sync {
    type TransferResponseFut: std::future::Future<Output = Result<EthernetTxTransferResult, fidl::Error>>
        + Send;
    fn r#transfer(&self, payload: &EthernetTxTransferRequest) -> Self::TransferResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct EthernetTxSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for EthernetTxSynchronousProxy {
    type Proxy = EthernetTxProxy;
    type Protocol = EthernetTxMarker;

    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 EthernetTxSynchronousProxy {
    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<EthernetTxEvent, fidl::Error> {
        EthernetTxEvent::decode(self.client.wait_for_event::<EthernetTxMarker>(deadline)?)
    }

    pub fn r#transfer(
        &self,
        mut payload: &EthernetTxTransferRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EthernetTxTransferResult, fidl::Error> {
        let _response = self.client.send_query::<
            EthernetTxTransferRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            EthernetTxMarker,
        >(
            payload,
            0x616dafedf07d00e7,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for EthernetTxProxy {
    type Protocol = EthernetTxMarker;

    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 EthernetTxProxy {
    /// Create a new Proxy for fuchsia.wlan.softmac/EthernetTx.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <EthernetTxMarker 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) -> EthernetTxEventStream {
        EthernetTxEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#transfer(
        &self,
        mut payload: &EthernetTxTransferRequest,
    ) -> fidl::client::QueryResponseFut<
        EthernetTxTransferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        EthernetTxProxyInterface::r#transfer(self, payload)
    }
}

impl EthernetTxProxyInterface for EthernetTxProxy {
    type TransferResponseFut = fidl::client::QueryResponseFut<
        EthernetTxTransferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#transfer(&self, mut payload: &EthernetTxTransferRequest) -> Self::TransferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EthernetTxTransferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x616dafedf07d00e7,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<EthernetTxTransferRequest, EthernetTxTransferResult>(
            payload,
            0x616dafedf07d00e7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for EthernetTxEventStream {
    type Item = Result<EthernetTxEvent, 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(EthernetTxEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

impl EthernetTxEvent {
    /// Decodes a message buffer as a [`EthernetTxEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<EthernetTxEvent, 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: <EthernetTxMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for EthernetTxRequestStream {
    type Protocol = EthernetTxMarker;
    type ControlHandle = EthernetTxControlHandle;

    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 {
        EthernetTxControlHandle { 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 EthernetTxRequestStream {
    type Item = Result<EthernetTxRequest, 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 EthernetTxRequestStream 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 {
                    0x616dafedf07d00e7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            EthernetTxTransferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EthernetTxTransferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = EthernetTxControlHandle { inner: this.inner.clone() };
                        Ok(EthernetTxRequest::Transfer {
                            payload: req,
                            responder: EthernetTxTransferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <EthernetTxMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol for sending an Ethernet frame from the wlansoftmac driver to the bridged
/// wlansoftmac driver.
///
/// # Experimental
///
/// This protocol is implemented as a foreign function interface (FFI)
/// between the wlansoftmac driver and the bridged driver solely to improve
/// the performance of processing data frames through the wlan-mlme library.
///
/// # Safety
///
/// The `complete_borrowed_operation` field must be a function pointer of the type
/// void (*)(eth::BorrowedOperation<>*, zx_status_t) where the first argument
/// is the value of `borrowed_operation` field.
///
/// Calling `complete_borrowed_operation` will result in calling
/// `eth::BorrowedOperation<>::Complete()` to release ownership of the packet. This
/// must be called exactly once. Failing to call `complete_borrowed_operation`
/// will leak memory, and calling more than once will result in use-after-free.
#[derive(Debug)]
pub enum EthernetTxRequest {
    Transfer { payload: EthernetTxTransferRequest, responder: EthernetTxTransferResponder },
}

impl EthernetTxRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_transfer(self) -> Option<(EthernetTxTransferRequest, EthernetTxTransferResponder)> {
        if let EthernetTxRequest::Transfer { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

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

impl EthernetTxControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 EthernetTxControlHandle {}

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

/// Set the the channel to be shutdown (see [`EthernetTxControlHandle::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 EthernetTxTransferResponder {
    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 EthernetTxTransferResponder {
    type ControlHandle = EthernetTxControlHandle;

    fn control_handle(&self) -> &EthernetTxControlHandle {
        &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 EthernetTxTransferResponder {
    /// 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,
                0x616dafedf07d00e7,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

impl fidl::endpoints::ProtocolMarker for WlanRxMarker {
    type Proxy = WlanRxProxy;
    type RequestStream = WlanRxRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = WlanRxSynchronousProxy;

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

pub trait WlanRxProxyInterface: Send + Sync {
    type TransferResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#transfer(&self, payload: &WlanRxTransferRequest) -> Self::TransferResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct WlanRxSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for WlanRxSynchronousProxy {
    type Proxy = WlanRxProxy;
    type Protocol = WlanRxMarker;

    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 WlanRxSynchronousProxy {
    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<WlanRxEvent, fidl::Error> {
        WlanRxEvent::decode(self.client.wait_for_event::<WlanRxMarker>(deadline)?)
    }

    pub fn r#transfer(
        &self,
        mut payload: &WlanRxTransferRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<WlanRxTransferRequest, fidl::encoding::EmptyPayload, WlanRxMarker>(
                payload,
                0x2c73b18cbfca6055,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for WlanRxProxy {
    type Protocol = WlanRxMarker;

    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 WlanRxProxy {
    /// Create a new Proxy for fuchsia.wlan.softmac/WlanRx.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <WlanRxMarker 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) -> WlanRxEventStream {
        WlanRxEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#transfer(
        &self,
        mut payload: &WlanRxTransferRequest,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        WlanRxProxyInterface::r#transfer(self, payload)
    }
}

impl WlanRxProxyInterface for WlanRxProxy {
    type TransferResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#transfer(&self, mut payload: &WlanRxTransferRequest) -> Self::TransferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2c73b18cbfca6055,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<WlanRxTransferRequest, ()>(
            payload,
            0x2c73b18cbfca6055,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for WlanRxEventStream {
    type Item = Result<WlanRxEvent, 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(WlanRxEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

impl WlanRxEvent {
    /// Decodes a message buffer as a [`WlanRxEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<WlanRxEvent, 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: <WlanRxMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for WlanRxRequestStream {
    type Protocol = WlanRxMarker;
    type ControlHandle = WlanRxControlHandle;

    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 {
        WlanRxControlHandle { 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 WlanRxRequestStream {
    type Item = Result<WlanRxRequest, 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 WlanRxRequestStream 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 {
                    0x2c73b18cbfca6055 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanRxTransferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanRxTransferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = WlanRxControlHandle { inner: this.inner.clone() };
                        Ok(WlanRxRequest::Transfer {
                            payload: req,
                            responder: WlanRxTransferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <WlanRxMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol for sending a WLAN frame from the wlansoftmac driver to the bridged
/// wlansoftmac driver.
///
/// # Experimental
///
/// This protocol is implemented as a foreign function interface (FFI)
/// between the wlansoftmac driver and the bridged driver solely to improve
/// the performance of processing data frames through the wlan-mlme library.
#[derive(Debug)]
pub enum WlanRxRequest {
    Transfer { payload: WlanRxTransferRequest, responder: WlanRxTransferResponder },
}

impl WlanRxRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_transfer(self) -> Option<(WlanRxTransferRequest, WlanRxTransferResponder)> {
        if let WlanRxRequest::Transfer { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

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

impl WlanRxControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 WlanRxControlHandle {}

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

/// Set the the channel to be shutdown (see [`WlanRxControlHandle::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 WlanRxTransferResponder {
    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 WlanRxTransferResponder {
    type ControlHandle = WlanRxControlHandle;

    fn control_handle(&self) -> &WlanRxControlHandle {
        &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 WlanRxTransferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        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) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x2c73b18cbfca6055,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for WlanSoftmacBaseMarker {
    type Proxy = WlanSoftmacBaseProxy;
    type RequestStream = WlanSoftmacBaseRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = WlanSoftmacBaseSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) WlanSoftmacBase";
}
pub type WlanSoftmacBaseQueryResult = Result<WlanSoftmacQueryResponse, i32>;
pub type WlanSoftmacBaseQueryDiscoverySupportResult = Result<DiscoverySupport, i32>;
pub type WlanSoftmacBaseQueryMacSublayerSupportResult =
    Result<fidl_fuchsia_wlan_common::MacSublayerSupport, i32>;
pub type WlanSoftmacBaseQuerySecuritySupportResult =
    Result<fidl_fuchsia_wlan_common::SecuritySupport, i32>;
pub type WlanSoftmacBaseQuerySpectrumManagementSupportResult =
    Result<fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>;
pub type WlanSoftmacBaseSetChannelResult = Result<(), i32>;
pub type WlanSoftmacBaseJoinBssResult = Result<(), i32>;
pub type WlanSoftmacBaseEnableBeaconingResult = Result<(), i32>;
pub type WlanSoftmacBaseDisableBeaconingResult = Result<(), i32>;
pub type WlanSoftmacBaseInstallKeyResult = Result<(), i32>;
pub type WlanSoftmacBaseNotifyAssociationCompleteResult = Result<(), i32>;
pub type WlanSoftmacBaseClearAssociationResult = Result<(), i32>;
pub type WlanSoftmacBaseStartPassiveScanResult =
    Result<WlanSoftmacBaseStartPassiveScanResponse, i32>;
pub type WlanSoftmacBaseStartActiveScanResult = Result<WlanSoftmacBaseStartActiveScanResponse, i32>;
pub type WlanSoftmacBaseCancelScanResult = Result<(), i32>;
pub type WlanSoftmacBaseUpdateWmmParametersResult = Result<(), i32>;

pub trait WlanSoftmacBaseProxyInterface: Send + Sync {
    type QueryResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseQueryResult, fidl::Error>>
        + Send;
    fn r#query(&self) -> Self::QueryResponseFut;
    type QueryDiscoverySupportResponseFut: std::future::Future<
            Output = Result<WlanSoftmacBaseQueryDiscoverySupportResult, fidl::Error>,
        > + Send;
    fn r#query_discovery_support(&self) -> Self::QueryDiscoverySupportResponseFut;
    type QueryMacSublayerSupportResponseFut: std::future::Future<
            Output = Result<WlanSoftmacBaseQueryMacSublayerSupportResult, fidl::Error>,
        > + Send;
    fn r#query_mac_sublayer_support(&self) -> Self::QueryMacSublayerSupportResponseFut;
    type QuerySecuritySupportResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseQuerySecuritySupportResult, fidl::Error>>
        + Send;
    fn r#query_security_support(&self) -> Self::QuerySecuritySupportResponseFut;
    type QuerySpectrumManagementSupportResponseFut: std::future::Future<
            Output = Result<WlanSoftmacBaseQuerySpectrumManagementSupportResult, fidl::Error>,
        > + Send;
    fn r#query_spectrum_management_support(
        &self,
    ) -> Self::QuerySpectrumManagementSupportResponseFut;
    type SetChannelResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseSetChannelResult, fidl::Error>>
        + Send;
    fn r#set_channel(
        &self,
        payload: &WlanSoftmacBaseSetChannelRequest,
    ) -> Self::SetChannelResponseFut;
    type JoinBssResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseJoinBssResult, fidl::Error>>
        + Send;
    fn r#join_bss(
        &self,
        join_request: &fidl_fuchsia_wlan_driver::JoinBssRequest,
    ) -> Self::JoinBssResponseFut;
    type EnableBeaconingResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseEnableBeaconingResult, fidl::Error>>
        + Send;
    fn r#enable_beaconing(
        &self,
        payload: &WlanSoftmacBaseEnableBeaconingRequest,
    ) -> Self::EnableBeaconingResponseFut;
    type DisableBeaconingResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseDisableBeaconingResult, fidl::Error>>
        + Send;
    fn r#disable_beaconing(&self) -> Self::DisableBeaconingResponseFut;
    type InstallKeyResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseInstallKeyResult, fidl::Error>>
        + Send;
    fn r#install_key(&self, payload: &WlanKeyConfiguration) -> Self::InstallKeyResponseFut;
    type NotifyAssociationCompleteResponseFut: std::future::Future<
            Output = Result<WlanSoftmacBaseNotifyAssociationCompleteResult, fidl::Error>,
        > + Send;
    fn r#notify_association_complete(
        &self,
        assoc_cfg: &WlanAssociationConfig,
    ) -> Self::NotifyAssociationCompleteResponseFut;
    type ClearAssociationResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseClearAssociationResult, fidl::Error>>
        + Send;
    fn r#clear_association(
        &self,
        payload: &WlanSoftmacBaseClearAssociationRequest,
    ) -> Self::ClearAssociationResponseFut;
    type StartPassiveScanResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseStartPassiveScanResult, fidl::Error>>
        + Send;
    fn r#start_passive_scan(
        &self,
        payload: &WlanSoftmacBaseStartPassiveScanRequest,
    ) -> Self::StartPassiveScanResponseFut;
    type StartActiveScanResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseStartActiveScanResult, fidl::Error>>
        + Send;
    fn r#start_active_scan(
        &self,
        payload: &WlanSoftmacStartActiveScanRequest,
    ) -> Self::StartActiveScanResponseFut;
    type CancelScanResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseCancelScanResult, fidl::Error>>
        + Send;
    fn r#cancel_scan(
        &self,
        payload: &WlanSoftmacBaseCancelScanRequest,
    ) -> Self::CancelScanResponseFut;
    type UpdateWmmParametersResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseUpdateWmmParametersResult, fidl::Error>>
        + Send;
    fn r#update_wmm_parameters(
        &self,
        payload: &WlanSoftmacBaseUpdateWmmParametersRequest,
    ) -> Self::UpdateWmmParametersResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct WlanSoftmacBaseSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for WlanSoftmacBaseSynchronousProxy {
    type Proxy = WlanSoftmacBaseProxy;
    type Protocol = WlanSoftmacBaseMarker;

    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 WlanSoftmacBaseSynchronousProxy {
    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<WlanSoftmacBaseEvent, fidl::Error> {
        WlanSoftmacBaseEvent::decode(self.client.wait_for_event::<WlanSoftmacBaseMarker>(deadline)?)
    }

    /// Gets general information about the device and its supported features.
    /// This method is safe to call even when the SoftMAC has not yet started.
    ///
    /// Note: The implementation of this method must not depend on a response
    /// from an ethernet driver, otherwise there is a risk of deadlock.
    /// The wlansoftmac driver calls this method synchronously while
    /// serving the fuchsia.hardware.ethernet/EthernetImpl.Query method.
    pub fn r#query(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseQueryResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<WlanSoftmacQueryResponse, i32>,
            WlanSoftmacBaseMarker,
        >(
            (),
            0x18231a638e508f9d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Gets information about the station discovery (e.g., scanning and
    /// probing) features supported by the device. This method is safe to call
    /// even when the SoftMAC has not yet started.
    pub fn r#query_discovery_support(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseQueryDiscoverySupportResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                WlanSoftmacBaseQueryDiscoverySupportResponse,
                i32,
            >, WlanSoftmacBaseMarker>(
                (),
                0x16797affc0cb58ae,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.resp))
    }

    /// Gets information about the MAC features supported by the device. This
    /// method is safe to call even when the SoftMAC has not yet started.
    ///
    /// Note: The implementation of this method must not depend on a response
    /// from an ethernet driver, otherwise there is a risk of deadlock.
    /// The wlansoftmac driver calls this method synchronously while
    /// serving the fuchsia.hardware.ethernet/EthernetImpl.Query method.
    pub fn r#query_mac_sublayer_support(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseQueryMacSublayerSupportResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                WlanSoftmacBaseQueryMacSublayerSupportResponse,
                i32,
            >, WlanSoftmacBaseMarker>(
                (),
                0x7302c3f8c131f075,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.resp))
    }

    /// Gets information about the security features supported by the device.
    /// This method is safe to call even when the SoftMAC has not yet started.
    pub fn r#query_security_support(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseQuerySecuritySupportResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                WlanSoftmacBaseQuerySecuritySupportResponse,
                i32,
            >, WlanSoftmacBaseMarker>(
                (),
                0x3691bb75abf6354,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.resp))
    }

    /// Gets information about the spectrum usage (e.g., DFS) features supported
    /// by the device. This method is safe to call even when the SoftMAC has not
    /// yet started.
    pub fn r#query_spectrum_management_support(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseQuerySpectrumManagementSupportResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                WlanSoftmacBaseQuerySpectrumManagementSupportResponse,
                i32,
            >, WlanSoftmacBaseMarker>(
                (),
                0x347d78dc1d4d27bf,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.resp))
    }

    /// Set the primary radio channel, e.g. in response to a channel switch event.
    /// If successful, this will trigger the channel switch immediately. This may
    /// impact the transmission of any frames that are in-flight, and might also
    /// interfere with an ongoing scan request.
    ///
    /// Common errors include: \
    ///   ZX_ERR_NOT_SUPPORTED: The device cannot switch to the requested channel.
    pub fn r#set_channel(
        &self,
        mut payload: &WlanSoftmacBaseSetChannelRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseSetChannelResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseSetChannelRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBaseMarker,
        >(
            payload,
            0x12836b533cd63ece,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Join a specific BSS in which we will participate.
    /// This applies regardless of if we are hosting the BSS or joining it
    /// (indicated by the `remote` flag in `JoinBssRequest`).
    /// If successful, the device will switch to the correct channel and perform
    /// any internal filtering/timing operations required to join the BSS.
    /// For client STAs, this is the first step before authenticating.
    ///
    /// Common errors include: \
    ///   ZX_ERR_NOT_SUPPORTED: The device does not support the given bss config.
    pub fn r#join_bss(
        &self,
        mut join_request: &fidl_fuchsia_wlan_driver::JoinBssRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseJoinBssResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseJoinBssRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBaseMarker,
        >(
            (join_request,),
            0x1336fb5455b77a6e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Enables hardware Beaconing.
    ///
    /// This method cannot be called while beaconing is enabled and so
    /// `DisableBeaconing` must be called prior to this method if beaconing is
    /// enabled.
    ///
    /// All request fields are required.
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_NOT_SUPPORTED`: The device does not support hardware beacons.
    /// - `ZX_ERR_INVALID_ARGS`: The device cannot transmit the requested
    ///                          beacon.
    /// - `ZX_ERR_BAD_STATE`: The device is already beaconing.
    pub fn r#enable_beaconing(
        &self,
        mut payload: &WlanSoftmacBaseEnableBeaconingRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseEnableBeaconingResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseEnableBeaconingRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBaseMarker,
        >(
            payload,
            0x6c35807632c64576,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Disables hardware beaconing.
    pub fn r#disable_beaconing(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseDisableBeaconingResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBaseMarker,
        >(
            (),
            0x3303b30f99dbb406,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Install a key for encryption when transmitting or receiving protected
    /// frames.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The given config does not specify a valid key.
    ///   ZX_ERR_NOT_SUPPORTED: The device does not support the given cipher.
    pub fn r#install_key(
        &self,
        mut payload: &WlanKeyConfiguration,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseInstallKeyResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanKeyConfiguration,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBaseMarker,
        >(
            payload,
            0x7decf9b4200b9131,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Notifies the device of a successful association and configures
    /// additional parameters necessary to participate in that association.
    ///
    /// # Errors
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_BAD_STATE`: The device was not previously informed of this BSS
    ///                       via `WlanSoftmac.JoinBss`.
    pub fn r#notify_association_complete(
        &self,
        mut assoc_cfg: &WlanAssociationConfig,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseNotifyAssociationCompleteResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseNotifyAssociationCompleteRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBaseMarker,
        >(
            (assoc_cfg,),
            0x436ffe3ba461d6cd,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Notifies MAC and PHY that the peer has been de-associated.
    pub fn r#clear_association(
        &self,
        mut payload: &WlanSoftmacBaseClearAssociationRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseClearAssociationResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseClearAssociationRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBaseMarker,
        >(
            payload,
            0x581d76c39190a7dd,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Starts a passive scan. The server will deliver scan results
    /// as Beacon frames using WlanSoftmacIfc.Recv(). When complete,
    /// the server will call WlanSoftmacIfc.ScanComplete() with the
    /// same `scan_id` returned by StartPassiveScan().
    ///
    /// The server indicates support for `StartPassiveScan()` using
    /// `fuchsia.wlan.common/ScanOffloadExtension.supported`.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The device is not capable of performing the
    ///       requested scan, e.g. because an incompatible channel was requested.
    ///   ZX_ERR_UNAVAILABLE: The device cannot currently perform scans.
    ///   ZX_ERR_SHOULD_WAIT: Another scan is already in-progress.
    pub fn r#start_passive_scan(
        &self,
        mut payload: &WlanSoftmacBaseStartPassiveScanRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseStartPassiveScanResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseStartPassiveScanRequest,
            fidl::encoding::ResultType<WlanSoftmacBaseStartPassiveScanResponse, i32>,
            WlanSoftmacBaseMarker,
        >(
            payload,
            0x5662f989cb4083bb,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Starts an active scan. The server will deliver scan results
    /// as Beacon or Probe Response frames using WlanSoftmacIfc.Recv().
    /// When complete, the server will call WlanSoftmacIfc.ScanComplete()
    /// with the same `scan_id` returned by StartActiveScan().
    ///
    /// A device driver indicates support for `StartActiveScan()` using
    /// `fuchsia.wlan.common/ProbeRequestOffloadExtension.supported`.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The device is not capable of performing the
    ///       requested scan, e.g. because an incompatible channel was requested.
    ///   ZX_ERR_UNAVAILABLE: The device cannot currently perform scans.
    ///   ZX_ERR_SHOULD_WAIT: Another scan is already in-progress.
    pub fn r#start_active_scan(
        &self,
        mut payload: &WlanSoftmacStartActiveScanRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseStartActiveScanResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacStartActiveScanRequest,
            fidl::encoding::ResultType<WlanSoftmacBaseStartActiveScanResponse, i32>,
            WlanSoftmacBaseMarker,
        >(
            payload,
            0x4896eafa9937751e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Cancels the ongoing scan corresponding to `scan_id`,
    /// where `scan_id` is an identifier returned by
    /// `StartPassiveScan()` or `StartActiveScan()`. If cancellation succeeds,
    /// the server will soon call WlanSoftmacIfc.ScanComplete() with the same
    /// `scan_id`.
    ///
    /// A device driver indicates support for `CancelScan()` using
    /// `fuchsia.wlan.common/ScanOffloadExtension.scan_cancel_supported`.
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_NOT_FOUND`: `scan_id` does not match an ongoing scan.
    /// - `ZX_ERR_NOT_SUPPORTED`: Server does not support scan cancellation.
    pub fn r#cancel_scan(
        &self,
        mut payload: &WlanSoftmacBaseCancelScanRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseCancelScanResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseCancelScanRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBaseMarker,
        >(
            payload,
            0xf7d859369764556,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Indicate the device of modified WiFi Multimedia (WMM) parameters for a
    /// particular access category (AC).
    pub fn r#update_wmm_parameters(
        &self,
        mut payload: &WlanSoftmacBaseUpdateWmmParametersRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseUpdateWmmParametersResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseUpdateWmmParametersRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBaseMarker,
        >(
            payload,
            0x68522c7122d5f78c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for WlanSoftmacBaseProxy {
    type Protocol = WlanSoftmacBaseMarker;

    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 WlanSoftmacBaseProxy {
    /// Create a new Proxy for fuchsia.wlan.softmac/WlanSoftmacBase.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <WlanSoftmacBaseMarker 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) -> WlanSoftmacBaseEventStream {
        WlanSoftmacBaseEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets general information about the device and its supported features.
    /// This method is safe to call even when the SoftMAC has not yet started.
    ///
    /// Note: The implementation of this method must not depend on a response
    /// from an ethernet driver, otherwise there is a risk of deadlock.
    /// The wlansoftmac driver calls this method synchronously while
    /// serving the fuchsia.hardware.ethernet/EthernetImpl.Query method.
    pub fn r#query(
        &self,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseQueryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#query(self)
    }

    /// Gets information about the station discovery (e.g., scanning and
    /// probing) features supported by the device. This method is safe to call
    /// even when the SoftMAC has not yet started.
    pub fn r#query_discovery_support(
        &self,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseQueryDiscoverySupportResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#query_discovery_support(self)
    }

    /// Gets information about the MAC features supported by the device. This
    /// method is safe to call even when the SoftMAC has not yet started.
    ///
    /// Note: The implementation of this method must not depend on a response
    /// from an ethernet driver, otherwise there is a risk of deadlock.
    /// The wlansoftmac driver calls this method synchronously while
    /// serving the fuchsia.hardware.ethernet/EthernetImpl.Query method.
    pub fn r#query_mac_sublayer_support(
        &self,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseQueryMacSublayerSupportResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#query_mac_sublayer_support(self)
    }

    /// Gets information about the security features supported by the device.
    /// This method is safe to call even when the SoftMAC has not yet started.
    pub fn r#query_security_support(
        &self,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseQuerySecuritySupportResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#query_security_support(self)
    }

    /// Gets information about the spectrum usage (e.g., DFS) features supported
    /// by the device. This method is safe to call even when the SoftMAC has not
    /// yet started.
    pub fn r#query_spectrum_management_support(
        &self,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseQuerySpectrumManagementSupportResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#query_spectrum_management_support(self)
    }

    /// Set the primary radio channel, e.g. in response to a channel switch event.
    /// If successful, this will trigger the channel switch immediately. This may
    /// impact the transmission of any frames that are in-flight, and might also
    /// interfere with an ongoing scan request.
    ///
    /// Common errors include: \
    ///   ZX_ERR_NOT_SUPPORTED: The device cannot switch to the requested channel.
    pub fn r#set_channel(
        &self,
        mut payload: &WlanSoftmacBaseSetChannelRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseSetChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#set_channel(self, payload)
    }

    /// Join a specific BSS in which we will participate.
    /// This applies regardless of if we are hosting the BSS or joining it
    /// (indicated by the `remote` flag in `JoinBssRequest`).
    /// If successful, the device will switch to the correct channel and perform
    /// any internal filtering/timing operations required to join the BSS.
    /// For client STAs, this is the first step before authenticating.
    ///
    /// Common errors include: \
    ///   ZX_ERR_NOT_SUPPORTED: The device does not support the given bss config.
    pub fn r#join_bss(
        &self,
        mut join_request: &fidl_fuchsia_wlan_driver::JoinBssRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseJoinBssResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#join_bss(self, join_request)
    }

    /// Enables hardware Beaconing.
    ///
    /// This method cannot be called while beaconing is enabled and so
    /// `DisableBeaconing` must be called prior to this method if beaconing is
    /// enabled.
    ///
    /// All request fields are required.
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_NOT_SUPPORTED`: The device does not support hardware beacons.
    /// - `ZX_ERR_INVALID_ARGS`: The device cannot transmit the requested
    ///                          beacon.
    /// - `ZX_ERR_BAD_STATE`: The device is already beaconing.
    pub fn r#enable_beaconing(
        &self,
        mut payload: &WlanSoftmacBaseEnableBeaconingRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseEnableBeaconingResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#enable_beaconing(self, payload)
    }

    /// Disables hardware beaconing.
    pub fn r#disable_beaconing(
        &self,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseDisableBeaconingResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#disable_beaconing(self)
    }

    /// Install a key for encryption when transmitting or receiving protected
    /// frames.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The given config does not specify a valid key.
    ///   ZX_ERR_NOT_SUPPORTED: The device does not support the given cipher.
    pub fn r#install_key(
        &self,
        mut payload: &WlanKeyConfiguration,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseInstallKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#install_key(self, payload)
    }

    /// Notifies the device of a successful association and configures
    /// additional parameters necessary to participate in that association.
    ///
    /// # Errors
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_BAD_STATE`: The device was not previously informed of this BSS
    ///                       via `WlanSoftmac.JoinBss`.
    pub fn r#notify_association_complete(
        &self,
        mut assoc_cfg: &WlanAssociationConfig,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseNotifyAssociationCompleteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#notify_association_complete(self, assoc_cfg)
    }

    /// Notifies MAC and PHY that the peer has been de-associated.
    pub fn r#clear_association(
        &self,
        mut payload: &WlanSoftmacBaseClearAssociationRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseClearAssociationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#clear_association(self, payload)
    }

    /// Starts a passive scan. The server will deliver scan results
    /// as Beacon frames using WlanSoftmacIfc.Recv(). When complete,
    /// the server will call WlanSoftmacIfc.ScanComplete() with the
    /// same `scan_id` returned by StartPassiveScan().
    ///
    /// The server indicates support for `StartPassiveScan()` using
    /// `fuchsia.wlan.common/ScanOffloadExtension.supported`.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The device is not capable of performing the
    ///       requested scan, e.g. because an incompatible channel was requested.
    ///   ZX_ERR_UNAVAILABLE: The device cannot currently perform scans.
    ///   ZX_ERR_SHOULD_WAIT: Another scan is already in-progress.
    pub fn r#start_passive_scan(
        &self,
        mut payload: &WlanSoftmacBaseStartPassiveScanRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseStartPassiveScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#start_passive_scan(self, payload)
    }

    /// Starts an active scan. The server will deliver scan results
    /// as Beacon or Probe Response frames using WlanSoftmacIfc.Recv().
    /// When complete, the server will call WlanSoftmacIfc.ScanComplete()
    /// with the same `scan_id` returned by StartActiveScan().
    ///
    /// A device driver indicates support for `StartActiveScan()` using
    /// `fuchsia.wlan.common/ProbeRequestOffloadExtension.supported`.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The device is not capable of performing the
    ///       requested scan, e.g. because an incompatible channel was requested.
    ///   ZX_ERR_UNAVAILABLE: The device cannot currently perform scans.
    ///   ZX_ERR_SHOULD_WAIT: Another scan is already in-progress.
    pub fn r#start_active_scan(
        &self,
        mut payload: &WlanSoftmacStartActiveScanRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseStartActiveScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#start_active_scan(self, payload)
    }

    /// Cancels the ongoing scan corresponding to `scan_id`,
    /// where `scan_id` is an identifier returned by
    /// `StartPassiveScan()` or `StartActiveScan()`. If cancellation succeeds,
    /// the server will soon call WlanSoftmacIfc.ScanComplete() with the same
    /// `scan_id`.
    ///
    /// A device driver indicates support for `CancelScan()` using
    /// `fuchsia.wlan.common/ScanOffloadExtension.scan_cancel_supported`.
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_NOT_FOUND`: `scan_id` does not match an ongoing scan.
    /// - `ZX_ERR_NOT_SUPPORTED`: Server does not support scan cancellation.
    pub fn r#cancel_scan(
        &self,
        mut payload: &WlanSoftmacBaseCancelScanRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseCancelScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#cancel_scan(self, payload)
    }

    /// Indicate the device of modified WiFi Multimedia (WMM) parameters for a
    /// particular access category (AC).
    pub fn r#update_wmm_parameters(
        &self,
        mut payload: &WlanSoftmacBaseUpdateWmmParametersRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseUpdateWmmParametersResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBaseProxyInterface::r#update_wmm_parameters(self, payload)
    }
}

impl WlanSoftmacBaseProxyInterface for WlanSoftmacBaseProxy {
    type QueryResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseQueryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query(&self) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseQueryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<WlanSoftmacQueryResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x18231a638e508f9d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, WlanSoftmacBaseQueryResult>(
                (),
                0x18231a638e508f9d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

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

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

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

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

    type SetChannelResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseSetChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_channel(
        &self,
        mut payload: &WlanSoftmacBaseSetChannelRequest,
    ) -> Self::SetChannelResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseSetChannelResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x12836b533cd63ece,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacBaseSetChannelRequest,
            WlanSoftmacBaseSetChannelResult,
        >(
            payload,
            0x12836b533cd63ece,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type JoinBssResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseJoinBssResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#join_bss(
        &self,
        mut join_request: &fidl_fuchsia_wlan_driver::JoinBssRequest,
    ) -> Self::JoinBssResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseJoinBssResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1336fb5455b77a6e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<WlanSoftmacBaseJoinBssRequest, WlanSoftmacBaseJoinBssResult>(
                (join_request,),
                0x1336fb5455b77a6e,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type EnableBeaconingResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseEnableBeaconingResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#enable_beaconing(
        &self,
        mut payload: &WlanSoftmacBaseEnableBeaconingRequest,
    ) -> Self::EnableBeaconingResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseEnableBeaconingResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6c35807632c64576,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacBaseEnableBeaconingRequest,
            WlanSoftmacBaseEnableBeaconingResult,
        >(
            payload,
            0x6c35807632c64576,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type InstallKeyResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseInstallKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#install_key(&self, mut payload: &WlanKeyConfiguration) -> Self::InstallKeyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseInstallKeyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7decf9b4200b9131,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<WlanKeyConfiguration, WlanSoftmacBaseInstallKeyResult>(
            payload,
            0x7decf9b4200b9131,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type NotifyAssociationCompleteResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseNotifyAssociationCompleteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#notify_association_complete(
        &self,
        mut assoc_cfg: &WlanAssociationConfig,
    ) -> Self::NotifyAssociationCompleteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseNotifyAssociationCompleteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x436ffe3ba461d6cd,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacBaseNotifyAssociationCompleteRequest,
            WlanSoftmacBaseNotifyAssociationCompleteResult,
        >(
            (assoc_cfg,),
            0x436ffe3ba461d6cd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ClearAssociationResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseClearAssociationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#clear_association(
        &self,
        mut payload: &WlanSoftmacBaseClearAssociationRequest,
    ) -> Self::ClearAssociationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseClearAssociationResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x581d76c39190a7dd,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacBaseClearAssociationRequest,
            WlanSoftmacBaseClearAssociationResult,
        >(
            payload,
            0x581d76c39190a7dd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartPassiveScanResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseStartPassiveScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start_passive_scan(
        &self,
        mut payload: &WlanSoftmacBaseStartPassiveScanRequest,
    ) -> Self::StartPassiveScanResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseStartPassiveScanResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<WlanSoftmacBaseStartPassiveScanResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5662f989cb4083bb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacBaseStartPassiveScanRequest,
            WlanSoftmacBaseStartPassiveScanResult,
        >(
            payload,
            0x5662f989cb4083bb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartActiveScanResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseStartActiveScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start_active_scan(
        &self,
        mut payload: &WlanSoftmacStartActiveScanRequest,
    ) -> Self::StartActiveScanResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseStartActiveScanResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<WlanSoftmacBaseStartActiveScanResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4896eafa9937751e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacStartActiveScanRequest,
            WlanSoftmacBaseStartActiveScanResult,
        >(
            payload,
            0x4896eafa9937751e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CancelScanResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseCancelScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#cancel_scan(
        &self,
        mut payload: &WlanSoftmacBaseCancelScanRequest,
    ) -> Self::CancelScanResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseCancelScanResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xf7d859369764556,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacBaseCancelScanRequest,
            WlanSoftmacBaseCancelScanResult,
        >(
            payload,
            0xf7d859369764556,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UpdateWmmParametersResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseUpdateWmmParametersResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#update_wmm_parameters(
        &self,
        mut payload: &WlanSoftmacBaseUpdateWmmParametersRequest,
    ) -> Self::UpdateWmmParametersResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseUpdateWmmParametersResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x68522c7122d5f78c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacBaseUpdateWmmParametersRequest,
            WlanSoftmacBaseUpdateWmmParametersResult,
        >(
            payload,
            0x68522c7122d5f78c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for WlanSoftmacBaseEventStream {
    type Item = Result<WlanSoftmacBaseEvent, 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(WlanSoftmacBaseEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum WlanSoftmacBaseEvent {
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl WlanSoftmacBaseEvent {
    /// Decodes a message buffer as a [`WlanSoftmacBaseEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<WlanSoftmacBaseEvent, 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 {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(WlanSoftmacBaseEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <WlanSoftmacBaseMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for WlanSoftmacBaseRequestStream {
    type Protocol = WlanSoftmacBaseMarker;
    type ControlHandle = WlanSoftmacBaseControlHandle;

    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 {
        WlanSoftmacBaseControlHandle { 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 WlanSoftmacBaseRequestStream {
    type Item = Result<WlanSoftmacBaseRequest, 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 WlanSoftmacBaseRequestStream 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 {
                    0x18231a638e508f9d => {
                        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 =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::Query {
                            responder: WlanSoftmacBaseQueryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x16797affc0cb58ae => {
                        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 =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::QueryDiscoverySupport {
                            responder: WlanSoftmacBaseQueryDiscoverySupportResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7302c3f8c131f075 => {
                        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 =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::QueryMacSublayerSupport {
                            responder: WlanSoftmacBaseQueryMacSublayerSupportResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3691bb75abf6354 => {
                        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 =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::QuerySecuritySupport {
                            responder: WlanSoftmacBaseQuerySecuritySupportResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x347d78dc1d4d27bf => {
                        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 =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::QuerySpectrumManagementSupport {
                            responder: WlanSoftmacBaseQuerySpectrumManagementSupportResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x12836b533cd63ece => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseSetChannelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseSetChannelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::SetChannel {
                            payload: req,
                            responder: WlanSoftmacBaseSetChannelResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1336fb5455b77a6e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseJoinBssRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseJoinBssRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::JoinBss {
                            join_request: req.join_request,

                            responder: WlanSoftmacBaseJoinBssResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6c35807632c64576 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseEnableBeaconingRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseEnableBeaconingRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::EnableBeaconing {
                            payload: req,
                            responder: WlanSoftmacBaseEnableBeaconingResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3303b30f99dbb406 => {
                        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 =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::DisableBeaconing {
                            responder: WlanSoftmacBaseDisableBeaconingResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7decf9b4200b9131 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanKeyConfiguration,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanKeyConfiguration>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::InstallKey {
                            payload: req,
                            responder: WlanSoftmacBaseInstallKeyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x436ffe3ba461d6cd => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseNotifyAssociationCompleteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseNotifyAssociationCompleteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::NotifyAssociationComplete {
                            assoc_cfg: req.assoc_cfg,

                            responder: WlanSoftmacBaseNotifyAssociationCompleteResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x581d76c39190a7dd => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseClearAssociationRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseClearAssociationRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::ClearAssociation {
                            payload: req,
                            responder: WlanSoftmacBaseClearAssociationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5662f989cb4083bb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseStartPassiveScanRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseStartPassiveScanRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::StartPassiveScan {
                            payload: req,
                            responder: WlanSoftmacBaseStartPassiveScanResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4896eafa9937751e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacStartActiveScanRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacStartActiveScanRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::StartActiveScan {
                            payload: req,
                            responder: WlanSoftmacBaseStartActiveScanResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xf7d859369764556 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseCancelScanRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseCancelScanRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::CancelScan {
                            payload: req,
                            responder: WlanSoftmacBaseCancelScanResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x68522c7122d5f78c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseUpdateWmmParametersRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseUpdateWmmParametersRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBaseControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBaseRequest::UpdateWmmParameters {
                            payload: req,
                            responder: WlanSoftmacBaseUpdateWmmParametersResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(WlanSoftmacBaseRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: WlanSoftmacBaseControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::OneWay,
                        })
                    }
                    _ if header
                        .dynamic_flags()
                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        this.inner.send_framework_err(
                            fidl::encoding::FrameworkErr::UnknownMethod,
                            header.tx_id,
                            header.ordinal,
                            header.dynamic_flags(),
                            (bytes, handles),
                        )?;
                        Ok(WlanSoftmacBaseRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: WlanSoftmacBaseControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <WlanSoftmacBaseMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// `WlanSoftmacBase` is a template protocol intended to be composed into
/// `WlanSoftmacBridge` and `WlanSoftmac`. `WlanSoftmacBase` contains all method
/// that both `WlanSoftmacBridge` and `WlanSoftmac` have in common.
/// `WlanSoftmacBase` should not be implemented directly.
///
/// NOTE: All methods use a `selector` attribute to maintain their ordinal
///       following migration from `WlanSoftmac` into this protocol. This is necessary
///       to preserve API compatibility.
#[derive(Debug)]
pub enum WlanSoftmacBaseRequest {
    /// Gets general information about the device and its supported features.
    /// This method is safe to call even when the SoftMAC has not yet started.
    ///
    /// Note: The implementation of this method must not depend on a response
    /// from an ethernet driver, otherwise there is a risk of deadlock.
    /// The wlansoftmac driver calls this method synchronously while
    /// serving the fuchsia.hardware.ethernet/EthernetImpl.Query method.
    Query { responder: WlanSoftmacBaseQueryResponder },
    /// Gets information about the station discovery (e.g., scanning and
    /// probing) features supported by the device. This method is safe to call
    /// even when the SoftMAC has not yet started.
    QueryDiscoverySupport { responder: WlanSoftmacBaseQueryDiscoverySupportResponder },
    /// Gets information about the MAC features supported by the device. This
    /// method is safe to call even when the SoftMAC has not yet started.
    ///
    /// Note: The implementation of this method must not depend on a response
    /// from an ethernet driver, otherwise there is a risk of deadlock.
    /// The wlansoftmac driver calls this method synchronously while
    /// serving the fuchsia.hardware.ethernet/EthernetImpl.Query method.
    QueryMacSublayerSupport { responder: WlanSoftmacBaseQueryMacSublayerSupportResponder },
    /// Gets information about the security features supported by the device.
    /// This method is safe to call even when the SoftMAC has not yet started.
    QuerySecuritySupport { responder: WlanSoftmacBaseQuerySecuritySupportResponder },
    /// Gets information about the spectrum usage (e.g., DFS) features supported
    /// by the device. This method is safe to call even when the SoftMAC has not
    /// yet started.
    QuerySpectrumManagementSupport {
        responder: WlanSoftmacBaseQuerySpectrumManagementSupportResponder,
    },
    /// Set the primary radio channel, e.g. in response to a channel switch event.
    /// If successful, this will trigger the channel switch immediately. This may
    /// impact the transmission of any frames that are in-flight, and might also
    /// interfere with an ongoing scan request.
    ///
    /// Common errors include: \
    ///   ZX_ERR_NOT_SUPPORTED: The device cannot switch to the requested channel.
    SetChannel {
        payload: WlanSoftmacBaseSetChannelRequest,
        responder: WlanSoftmacBaseSetChannelResponder,
    },
    /// Join a specific BSS in which we will participate.
    /// This applies regardless of if we are hosting the BSS or joining it
    /// (indicated by the `remote` flag in `JoinBssRequest`).
    /// If successful, the device will switch to the correct channel and perform
    /// any internal filtering/timing operations required to join the BSS.
    /// For client STAs, this is the first step before authenticating.
    ///
    /// Common errors include: \
    ///   ZX_ERR_NOT_SUPPORTED: The device does not support the given bss config.
    JoinBss {
        join_request: fidl_fuchsia_wlan_driver::JoinBssRequest,
        responder: WlanSoftmacBaseJoinBssResponder,
    },
    /// Enables hardware Beaconing.
    ///
    /// This method cannot be called while beaconing is enabled and so
    /// `DisableBeaconing` must be called prior to this method if beaconing is
    /// enabled.
    ///
    /// All request fields are required.
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_NOT_SUPPORTED`: The device does not support hardware beacons.
    /// - `ZX_ERR_INVALID_ARGS`: The device cannot transmit the requested
    ///                          beacon.
    /// - `ZX_ERR_BAD_STATE`: The device is already beaconing.
    EnableBeaconing {
        payload: WlanSoftmacBaseEnableBeaconingRequest,
        responder: WlanSoftmacBaseEnableBeaconingResponder,
    },
    /// Disables hardware beaconing.
    DisableBeaconing { responder: WlanSoftmacBaseDisableBeaconingResponder },
    /// Install a key for encryption when transmitting or receiving protected
    /// frames.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The given config does not specify a valid key.
    ///   ZX_ERR_NOT_SUPPORTED: The device does not support the given cipher.
    InstallKey { payload: WlanKeyConfiguration, responder: WlanSoftmacBaseInstallKeyResponder },
    /// Notifies the device of a successful association and configures
    /// additional parameters necessary to participate in that association.
    ///
    /// # Errors
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_BAD_STATE`: The device was not previously informed of this BSS
    ///                       via `WlanSoftmac.JoinBss`.
    NotifyAssociationComplete {
        assoc_cfg: WlanAssociationConfig,
        responder: WlanSoftmacBaseNotifyAssociationCompleteResponder,
    },
    /// Notifies MAC and PHY that the peer has been de-associated.
    ClearAssociation {
        payload: WlanSoftmacBaseClearAssociationRequest,
        responder: WlanSoftmacBaseClearAssociationResponder,
    },
    /// Starts a passive scan. The server will deliver scan results
    /// as Beacon frames using WlanSoftmacIfc.Recv(). When complete,
    /// the server will call WlanSoftmacIfc.ScanComplete() with the
    /// same `scan_id` returned by StartPassiveScan().
    ///
    /// The server indicates support for `StartPassiveScan()` using
    /// `fuchsia.wlan.common/ScanOffloadExtension.supported`.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The device is not capable of performing the
    ///       requested scan, e.g. because an incompatible channel was requested.
    ///   ZX_ERR_UNAVAILABLE: The device cannot currently perform scans.
    ///   ZX_ERR_SHOULD_WAIT: Another scan is already in-progress.
    StartPassiveScan {
        payload: WlanSoftmacBaseStartPassiveScanRequest,
        responder: WlanSoftmacBaseStartPassiveScanResponder,
    },
    /// Starts an active scan. The server will deliver scan results
    /// as Beacon or Probe Response frames using WlanSoftmacIfc.Recv().
    /// When complete, the server will call WlanSoftmacIfc.ScanComplete()
    /// with the same `scan_id` returned by StartActiveScan().
    ///
    /// A device driver indicates support for `StartActiveScan()` using
    /// `fuchsia.wlan.common/ProbeRequestOffloadExtension.supported`.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The device is not capable of performing the
    ///       requested scan, e.g. because an incompatible channel was requested.
    ///   ZX_ERR_UNAVAILABLE: The device cannot currently perform scans.
    ///   ZX_ERR_SHOULD_WAIT: Another scan is already in-progress.
    StartActiveScan {
        payload: WlanSoftmacStartActiveScanRequest,
        responder: WlanSoftmacBaseStartActiveScanResponder,
    },
    /// Cancels the ongoing scan corresponding to `scan_id`,
    /// where `scan_id` is an identifier returned by
    /// `StartPassiveScan()` or `StartActiveScan()`. If cancellation succeeds,
    /// the server will soon call WlanSoftmacIfc.ScanComplete() with the same
    /// `scan_id`.
    ///
    /// A device driver indicates support for `CancelScan()` using
    /// `fuchsia.wlan.common/ScanOffloadExtension.scan_cancel_supported`.
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_NOT_FOUND`: `scan_id` does not match an ongoing scan.
    /// - `ZX_ERR_NOT_SUPPORTED`: Server does not support scan cancellation.
    CancelScan {
        payload: WlanSoftmacBaseCancelScanRequest,
        responder: WlanSoftmacBaseCancelScanResponder,
    },
    /// Indicate the device of modified WiFi Multimedia (WMM) parameters for a
    /// particular access category (AC).
    UpdateWmmParameters {
        payload: WlanSoftmacBaseUpdateWmmParametersRequest,
        responder: WlanSoftmacBaseUpdateWmmParametersResponder,
    },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: WlanSoftmacBaseControlHandle,
        method_type: fidl::MethodType,
    },
}

impl WlanSoftmacBaseRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_query(self) -> Option<(WlanSoftmacBaseQueryResponder)> {
        if let WlanSoftmacBaseRequest::Query { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_discovery_support(
        self,
    ) -> Option<(WlanSoftmacBaseQueryDiscoverySupportResponder)> {
        if let WlanSoftmacBaseRequest::QueryDiscoverySupport { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_mac_sublayer_support(
        self,
    ) -> Option<(WlanSoftmacBaseQueryMacSublayerSupportResponder)> {
        if let WlanSoftmacBaseRequest::QueryMacSublayerSupport { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_security_support(
        self,
    ) -> Option<(WlanSoftmacBaseQuerySecuritySupportResponder)> {
        if let WlanSoftmacBaseRequest::QuerySecuritySupport { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_spectrum_management_support(
        self,
    ) -> Option<(WlanSoftmacBaseQuerySpectrumManagementSupportResponder)> {
        if let WlanSoftmacBaseRequest::QuerySpectrumManagementSupport { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_channel(
        self,
    ) -> Option<(WlanSoftmacBaseSetChannelRequest, WlanSoftmacBaseSetChannelResponder)> {
        if let WlanSoftmacBaseRequest::SetChannel { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_join_bss(
        self,
    ) -> Option<(fidl_fuchsia_wlan_driver::JoinBssRequest, WlanSoftmacBaseJoinBssResponder)> {
        if let WlanSoftmacBaseRequest::JoinBss { join_request, responder } = self {
            Some((join_request, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_enable_beaconing(
        self,
    ) -> Option<(WlanSoftmacBaseEnableBeaconingRequest, WlanSoftmacBaseEnableBeaconingResponder)>
    {
        if let WlanSoftmacBaseRequest::EnableBeaconing { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_disable_beaconing(self) -> Option<(WlanSoftmacBaseDisableBeaconingResponder)> {
        if let WlanSoftmacBaseRequest::DisableBeaconing { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_install_key(
        self,
    ) -> Option<(WlanKeyConfiguration, WlanSoftmacBaseInstallKeyResponder)> {
        if let WlanSoftmacBaseRequest::InstallKey { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_association_complete(
        self,
    ) -> Option<(WlanAssociationConfig, WlanSoftmacBaseNotifyAssociationCompleteResponder)> {
        if let WlanSoftmacBaseRequest::NotifyAssociationComplete { assoc_cfg, responder } = self {
            Some((assoc_cfg, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clear_association(
        self,
    ) -> Option<(WlanSoftmacBaseClearAssociationRequest, WlanSoftmacBaseClearAssociationResponder)>
    {
        if let WlanSoftmacBaseRequest::ClearAssociation { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start_passive_scan(
        self,
    ) -> Option<(WlanSoftmacBaseStartPassiveScanRequest, WlanSoftmacBaseStartPassiveScanResponder)>
    {
        if let WlanSoftmacBaseRequest::StartPassiveScan { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start_active_scan(
        self,
    ) -> Option<(WlanSoftmacStartActiveScanRequest, WlanSoftmacBaseStartActiveScanResponder)> {
        if let WlanSoftmacBaseRequest::StartActiveScan { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_cancel_scan(
        self,
    ) -> Option<(WlanSoftmacBaseCancelScanRequest, WlanSoftmacBaseCancelScanResponder)> {
        if let WlanSoftmacBaseRequest::CancelScan { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_update_wmm_parameters(
        self,
    ) -> Option<(
        WlanSoftmacBaseUpdateWmmParametersRequest,
        WlanSoftmacBaseUpdateWmmParametersResponder,
    )> {
        if let WlanSoftmacBaseRequest::UpdateWmmParameters { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            WlanSoftmacBaseRequest::Query { .. } => "query",
            WlanSoftmacBaseRequest::QueryDiscoverySupport { .. } => "query_discovery_support",
            WlanSoftmacBaseRequest::QueryMacSublayerSupport { .. } => "query_mac_sublayer_support",
            WlanSoftmacBaseRequest::QuerySecuritySupport { .. } => "query_security_support",
            WlanSoftmacBaseRequest::QuerySpectrumManagementSupport { .. } => {
                "query_spectrum_management_support"
            }
            WlanSoftmacBaseRequest::SetChannel { .. } => "set_channel",
            WlanSoftmacBaseRequest::JoinBss { .. } => "join_bss",
            WlanSoftmacBaseRequest::EnableBeaconing { .. } => "enable_beaconing",
            WlanSoftmacBaseRequest::DisableBeaconing { .. } => "disable_beaconing",
            WlanSoftmacBaseRequest::InstallKey { .. } => "install_key",
            WlanSoftmacBaseRequest::NotifyAssociationComplete { .. } => {
                "notify_association_complete"
            }
            WlanSoftmacBaseRequest::ClearAssociation { .. } => "clear_association",
            WlanSoftmacBaseRequest::StartPassiveScan { .. } => "start_passive_scan",
            WlanSoftmacBaseRequest::StartActiveScan { .. } => "start_active_scan",
            WlanSoftmacBaseRequest::CancelScan { .. } => "cancel_scan",
            WlanSoftmacBaseRequest::UpdateWmmParameters { .. } => "update_wmm_parameters",
            WlanSoftmacBaseRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay,
                ..
            } => "unknown one-way method",
            WlanSoftmacBaseRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay,
                ..
            } => "unknown two-way method",
        }
    }
}

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

impl WlanSoftmacBaseControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 WlanSoftmacBaseControlHandle {}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseQueryResponder {
    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 WlanSoftmacBaseQueryResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseQueryResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&WlanSoftmacQueryResponse, 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<&WlanSoftmacQueryResponse, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseQueryDiscoverySupportResponder {
    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 WlanSoftmacBaseQueryDiscoverySupportResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseQueryDiscoverySupportResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<&DiscoverySupport, 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<&DiscoverySupport, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseQueryMacSublayerSupportResponder {
    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 WlanSoftmacBaseQueryMacSublayerSupportResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseQueryMacSublayerSupportResponder {
    /// 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_common::MacSublayerSupport, 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_common::MacSublayerSupport, 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_common::MacSublayerSupport, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            WlanSoftmacBaseQueryMacSublayerSupportResponse,
            i32,
        >>(
            result.map(|resp| (resp,)),
            self.tx_id,
            0x7302c3f8c131f075,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseQuerySecuritySupportResponder {
    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 WlanSoftmacBaseQuerySecuritySupportResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseQuerySecuritySupportResponder {
    /// 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_common::SecuritySupport, 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_common::SecuritySupport, 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_common::SecuritySupport, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            WlanSoftmacBaseQuerySecuritySupportResponse,
            i32,
        >>(
            result.map(|resp| (resp,)),
            self.tx_id,
            0x3691bb75abf6354,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseQuerySpectrumManagementSupportResponder {
    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 WlanSoftmacBaseQuerySpectrumManagementSupportResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseQuerySpectrumManagementSupportResponder {
    /// 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_common::SpectrumManagementSupport, 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_common::SpectrumManagementSupport, 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_common::SpectrumManagementSupport, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            WlanSoftmacBaseQuerySpectrumManagementSupportResponse,
            i32,
        >>(
            result.map(|resp| (resp,)),
            self.tx_id,
            0x347d78dc1d4d27bf,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseSetChannelResponder {
    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 WlanSoftmacBaseSetChannelResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseSetChannelResponder {
    /// 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,
                0x12836b533cd63ece,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseJoinBssResponder {
    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 WlanSoftmacBaseJoinBssResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseJoinBssResponder {
    /// 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,
                0x1336fb5455b77a6e,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseEnableBeaconingResponder {
    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 WlanSoftmacBaseEnableBeaconingResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseEnableBeaconingResponder {
    /// 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,
                0x6c35807632c64576,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseDisableBeaconingResponder {
    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 WlanSoftmacBaseDisableBeaconingResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseDisableBeaconingResponder {
    /// 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,
                0x3303b30f99dbb406,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseInstallKeyResponder {
    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 WlanSoftmacBaseInstallKeyResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseInstallKeyResponder {
    /// 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,
                0x7decf9b4200b9131,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseNotifyAssociationCompleteResponder {
    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 WlanSoftmacBaseNotifyAssociationCompleteResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseNotifyAssociationCompleteResponder {
    /// 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,
                0x436ffe3ba461d6cd,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseClearAssociationResponder {
    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 WlanSoftmacBaseClearAssociationResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseClearAssociationResponder {
    /// 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,
                0x581d76c39190a7dd,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseStartPassiveScanResponder {
    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 WlanSoftmacBaseStartPassiveScanResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseStartPassiveScanResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&WlanSoftmacBaseStartPassiveScanResponse, 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<&WlanSoftmacBaseStartPassiveScanResponse, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseStartActiveScanResponder {
    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 WlanSoftmacBaseStartActiveScanResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseStartActiveScanResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&WlanSoftmacBaseStartActiveScanResponse, 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<&WlanSoftmacBaseStartActiveScanResponse, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseCancelScanResponder {
    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 WlanSoftmacBaseCancelScanResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseCancelScanResponder {
    /// 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,
                0xf7d859369764556,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBaseControlHandle::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 WlanSoftmacBaseUpdateWmmParametersResponder {
    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 WlanSoftmacBaseUpdateWmmParametersResponder {
    type ControlHandle = WlanSoftmacBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBaseControlHandle {
        &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 WlanSoftmacBaseUpdateWmmParametersResponder {
    /// 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,
                0x68522c7122d5f78c,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

impl fidl::endpoints::ProtocolMarker for WlanSoftmacBridgeMarker {
    type Proxy = WlanSoftmacBridgeProxy;
    type RequestStream = WlanSoftmacBridgeRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = WlanSoftmacBridgeSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) WlanSoftmacBridge";
}
pub type WlanSoftmacBridgeStartResult = Result<fidl::Channel, i32>;

pub trait WlanSoftmacBridgeProxyInterface: Send + Sync {
    type QueryResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseQueryResult, fidl::Error>>
        + Send;
    fn r#query(&self) -> Self::QueryResponseFut;
    type QueryDiscoverySupportResponseFut: std::future::Future<
            Output = Result<WlanSoftmacBaseQueryDiscoverySupportResult, fidl::Error>,
        > + Send;
    fn r#query_discovery_support(&self) -> Self::QueryDiscoverySupportResponseFut;
    type QueryMacSublayerSupportResponseFut: std::future::Future<
            Output = Result<WlanSoftmacBaseQueryMacSublayerSupportResult, fidl::Error>,
        > + Send;
    fn r#query_mac_sublayer_support(&self) -> Self::QueryMacSublayerSupportResponseFut;
    type QuerySecuritySupportResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseQuerySecuritySupportResult, fidl::Error>>
        + Send;
    fn r#query_security_support(&self) -> Self::QuerySecuritySupportResponseFut;
    type QuerySpectrumManagementSupportResponseFut: std::future::Future<
            Output = Result<WlanSoftmacBaseQuerySpectrumManagementSupportResult, fidl::Error>,
        > + Send;
    fn r#query_spectrum_management_support(
        &self,
    ) -> Self::QuerySpectrumManagementSupportResponseFut;
    type SetChannelResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseSetChannelResult, fidl::Error>>
        + Send;
    fn r#set_channel(
        &self,
        payload: &WlanSoftmacBaseSetChannelRequest,
    ) -> Self::SetChannelResponseFut;
    type JoinBssResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseJoinBssResult, fidl::Error>>
        + Send;
    fn r#join_bss(
        &self,
        join_request: &fidl_fuchsia_wlan_driver::JoinBssRequest,
    ) -> Self::JoinBssResponseFut;
    type EnableBeaconingResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseEnableBeaconingResult, fidl::Error>>
        + Send;
    fn r#enable_beaconing(
        &self,
        payload: &WlanSoftmacBaseEnableBeaconingRequest,
    ) -> Self::EnableBeaconingResponseFut;
    type DisableBeaconingResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseDisableBeaconingResult, fidl::Error>>
        + Send;
    fn r#disable_beaconing(&self) -> Self::DisableBeaconingResponseFut;
    type InstallKeyResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseInstallKeyResult, fidl::Error>>
        + Send;
    fn r#install_key(&self, payload: &WlanKeyConfiguration) -> Self::InstallKeyResponseFut;
    type NotifyAssociationCompleteResponseFut: std::future::Future<
            Output = Result<WlanSoftmacBaseNotifyAssociationCompleteResult, fidl::Error>,
        > + Send;
    fn r#notify_association_complete(
        &self,
        assoc_cfg: &WlanAssociationConfig,
    ) -> Self::NotifyAssociationCompleteResponseFut;
    type ClearAssociationResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseClearAssociationResult, fidl::Error>>
        + Send;
    fn r#clear_association(
        &self,
        payload: &WlanSoftmacBaseClearAssociationRequest,
    ) -> Self::ClearAssociationResponseFut;
    type StartPassiveScanResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseStartPassiveScanResult, fidl::Error>>
        + Send;
    fn r#start_passive_scan(
        &self,
        payload: &WlanSoftmacBaseStartPassiveScanRequest,
    ) -> Self::StartPassiveScanResponseFut;
    type StartActiveScanResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseStartActiveScanResult, fidl::Error>>
        + Send;
    fn r#start_active_scan(
        &self,
        payload: &WlanSoftmacStartActiveScanRequest,
    ) -> Self::StartActiveScanResponseFut;
    type CancelScanResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseCancelScanResult, fidl::Error>>
        + Send;
    fn r#cancel_scan(
        &self,
        payload: &WlanSoftmacBaseCancelScanRequest,
    ) -> Self::CancelScanResponseFut;
    type UpdateWmmParametersResponseFut: std::future::Future<Output = Result<WlanSoftmacBaseUpdateWmmParametersResult, fidl::Error>>
        + Send;
    fn r#update_wmm_parameters(
        &self,
        payload: &WlanSoftmacBaseUpdateWmmParametersRequest,
    ) -> Self::UpdateWmmParametersResponseFut;
    type StartResponseFut: std::future::Future<Output = Result<WlanSoftmacBridgeStartResult, fidl::Error>>
        + Send;
    fn r#start(
        &self,
        ifc_bridge: fidl::endpoints::ClientEnd<WlanSoftmacIfcBridgeMarker>,
        ethernet_tx: u64,
        wlan_rx: u64,
    ) -> Self::StartResponseFut;
    type SetEthernetStatusResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#set_ethernet_status(&self, status: u32) -> Self::SetEthernetStatusResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct WlanSoftmacBridgeSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for WlanSoftmacBridgeSynchronousProxy {
    type Proxy = WlanSoftmacBridgeProxy;
    type Protocol = WlanSoftmacBridgeMarker;

    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 WlanSoftmacBridgeSynchronousProxy {
    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<WlanSoftmacBridgeEvent, fidl::Error> {
        WlanSoftmacBridgeEvent::decode(
            self.client.wait_for_event::<WlanSoftmacBridgeMarker>(deadline)?,
        )
    }

    /// Gets general information about the device and its supported features.
    /// This method is safe to call even when the SoftMAC has not yet started.
    ///
    /// Note: The implementation of this method must not depend on a response
    /// from an ethernet driver, otherwise there is a risk of deadlock.
    /// The wlansoftmac driver calls this method synchronously while
    /// serving the fuchsia.hardware.ethernet/EthernetImpl.Query method.
    pub fn r#query(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseQueryResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<WlanSoftmacQueryResponse, i32>,
            WlanSoftmacBridgeMarker,
        >(
            (),
            0x18231a638e508f9d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Gets information about the station discovery (e.g., scanning and
    /// probing) features supported by the device. This method is safe to call
    /// even when the SoftMAC has not yet started.
    pub fn r#query_discovery_support(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseQueryDiscoverySupportResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                WlanSoftmacBaseQueryDiscoverySupportResponse,
                i32,
            >, WlanSoftmacBridgeMarker>(
                (),
                0x16797affc0cb58ae,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.resp))
    }

    /// Gets information about the MAC features supported by the device. This
    /// method is safe to call even when the SoftMAC has not yet started.
    ///
    /// Note: The implementation of this method must not depend on a response
    /// from an ethernet driver, otherwise there is a risk of deadlock.
    /// The wlansoftmac driver calls this method synchronously while
    /// serving the fuchsia.hardware.ethernet/EthernetImpl.Query method.
    pub fn r#query_mac_sublayer_support(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseQueryMacSublayerSupportResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                WlanSoftmacBaseQueryMacSublayerSupportResponse,
                i32,
            >, WlanSoftmacBridgeMarker>(
                (),
                0x7302c3f8c131f075,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.resp))
    }

    /// Gets information about the security features supported by the device.
    /// This method is safe to call even when the SoftMAC has not yet started.
    pub fn r#query_security_support(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseQuerySecuritySupportResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                WlanSoftmacBaseQuerySecuritySupportResponse,
                i32,
            >, WlanSoftmacBridgeMarker>(
                (),
                0x3691bb75abf6354,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.resp))
    }

    /// Gets information about the spectrum usage (e.g., DFS) features supported
    /// by the device. This method is safe to call even when the SoftMAC has not
    /// yet started.
    pub fn r#query_spectrum_management_support(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseQuerySpectrumManagementSupportResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                WlanSoftmacBaseQuerySpectrumManagementSupportResponse,
                i32,
            >, WlanSoftmacBridgeMarker>(
                (),
                0x347d78dc1d4d27bf,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.resp))
    }

    /// Set the primary radio channel, e.g. in response to a channel switch event.
    /// If successful, this will trigger the channel switch immediately. This may
    /// impact the transmission of any frames that are in-flight, and might also
    /// interfere with an ongoing scan request.
    ///
    /// Common errors include: \
    ///   ZX_ERR_NOT_SUPPORTED: The device cannot switch to the requested channel.
    pub fn r#set_channel(
        &self,
        mut payload: &WlanSoftmacBaseSetChannelRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseSetChannelResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseSetChannelRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBridgeMarker,
        >(
            payload,
            0x12836b533cd63ece,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Join a specific BSS in which we will participate.
    /// This applies regardless of if we are hosting the BSS or joining it
    /// (indicated by the `remote` flag in `JoinBssRequest`).
    /// If successful, the device will switch to the correct channel and perform
    /// any internal filtering/timing operations required to join the BSS.
    /// For client STAs, this is the first step before authenticating.
    ///
    /// Common errors include: \
    ///   ZX_ERR_NOT_SUPPORTED: The device does not support the given bss config.
    pub fn r#join_bss(
        &self,
        mut join_request: &fidl_fuchsia_wlan_driver::JoinBssRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseJoinBssResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseJoinBssRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBridgeMarker,
        >(
            (join_request,),
            0x1336fb5455b77a6e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Enables hardware Beaconing.
    ///
    /// This method cannot be called while beaconing is enabled and so
    /// `DisableBeaconing` must be called prior to this method if beaconing is
    /// enabled.
    ///
    /// All request fields are required.
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_NOT_SUPPORTED`: The device does not support hardware beacons.
    /// - `ZX_ERR_INVALID_ARGS`: The device cannot transmit the requested
    ///                          beacon.
    /// - `ZX_ERR_BAD_STATE`: The device is already beaconing.
    pub fn r#enable_beaconing(
        &self,
        mut payload: &WlanSoftmacBaseEnableBeaconingRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseEnableBeaconingResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseEnableBeaconingRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBridgeMarker,
        >(
            payload,
            0x6c35807632c64576,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Disables hardware beaconing.
    pub fn r#disable_beaconing(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseDisableBeaconingResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBridgeMarker,
        >(
            (),
            0x3303b30f99dbb406,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Install a key for encryption when transmitting or receiving protected
    /// frames.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The given config does not specify a valid key.
    ///   ZX_ERR_NOT_SUPPORTED: The device does not support the given cipher.
    pub fn r#install_key(
        &self,
        mut payload: &WlanKeyConfiguration,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseInstallKeyResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanKeyConfiguration,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBridgeMarker,
        >(
            payload,
            0x7decf9b4200b9131,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Notifies the device of a successful association and configures
    /// additional parameters necessary to participate in that association.
    ///
    /// # Errors
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_BAD_STATE`: The device was not previously informed of this BSS
    ///                       via `WlanSoftmac.JoinBss`.
    pub fn r#notify_association_complete(
        &self,
        mut assoc_cfg: &WlanAssociationConfig,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseNotifyAssociationCompleteResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseNotifyAssociationCompleteRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBridgeMarker,
        >(
            (assoc_cfg,),
            0x436ffe3ba461d6cd,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Notifies MAC and PHY that the peer has been de-associated.
    pub fn r#clear_association(
        &self,
        mut payload: &WlanSoftmacBaseClearAssociationRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseClearAssociationResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseClearAssociationRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBridgeMarker,
        >(
            payload,
            0x581d76c39190a7dd,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Starts a passive scan. The server will deliver scan results
    /// as Beacon frames using WlanSoftmacIfc.Recv(). When complete,
    /// the server will call WlanSoftmacIfc.ScanComplete() with the
    /// same `scan_id` returned by StartPassiveScan().
    ///
    /// The server indicates support for `StartPassiveScan()` using
    /// `fuchsia.wlan.common/ScanOffloadExtension.supported`.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The device is not capable of performing the
    ///       requested scan, e.g. because an incompatible channel was requested.
    ///   ZX_ERR_UNAVAILABLE: The device cannot currently perform scans.
    ///   ZX_ERR_SHOULD_WAIT: Another scan is already in-progress.
    pub fn r#start_passive_scan(
        &self,
        mut payload: &WlanSoftmacBaseStartPassiveScanRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseStartPassiveScanResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseStartPassiveScanRequest,
            fidl::encoding::ResultType<WlanSoftmacBaseStartPassiveScanResponse, i32>,
            WlanSoftmacBridgeMarker,
        >(
            payload,
            0x5662f989cb4083bb,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Starts an active scan. The server will deliver scan results
    /// as Beacon or Probe Response frames using WlanSoftmacIfc.Recv().
    /// When complete, the server will call WlanSoftmacIfc.ScanComplete()
    /// with the same `scan_id` returned by StartActiveScan().
    ///
    /// A device driver indicates support for `StartActiveScan()` using
    /// `fuchsia.wlan.common/ProbeRequestOffloadExtension.supported`.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The device is not capable of performing the
    ///       requested scan, e.g. because an incompatible channel was requested.
    ///   ZX_ERR_UNAVAILABLE: The device cannot currently perform scans.
    ///   ZX_ERR_SHOULD_WAIT: Another scan is already in-progress.
    pub fn r#start_active_scan(
        &self,
        mut payload: &WlanSoftmacStartActiveScanRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseStartActiveScanResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacStartActiveScanRequest,
            fidl::encoding::ResultType<WlanSoftmacBaseStartActiveScanResponse, i32>,
            WlanSoftmacBridgeMarker,
        >(
            payload,
            0x4896eafa9937751e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Cancels the ongoing scan corresponding to `scan_id`,
    /// where `scan_id` is an identifier returned by
    /// `StartPassiveScan()` or `StartActiveScan()`. If cancellation succeeds,
    /// the server will soon call WlanSoftmacIfc.ScanComplete() with the same
    /// `scan_id`.
    ///
    /// A device driver indicates support for `CancelScan()` using
    /// `fuchsia.wlan.common/ScanOffloadExtension.scan_cancel_supported`.
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_NOT_FOUND`: `scan_id` does not match an ongoing scan.
    /// - `ZX_ERR_NOT_SUPPORTED`: Server does not support scan cancellation.
    pub fn r#cancel_scan(
        &self,
        mut payload: &WlanSoftmacBaseCancelScanRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseCancelScanResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseCancelScanRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBridgeMarker,
        >(
            payload,
            0xf7d859369764556,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Indicate the device of modified WiFi Multimedia (WMM) parameters for a
    /// particular access category (AC).
    pub fn r#update_wmm_parameters(
        &self,
        mut payload: &WlanSoftmacBaseUpdateWmmParametersRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBaseUpdateWmmParametersResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBaseUpdateWmmParametersRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanSoftmacBridgeMarker,
        >(
            payload,
            0x68522c7122d5f78c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Signal to the server that the MLME for the iface is ready to send and receive
    /// frames.
    ///
    /// The client provides the following arguments:
    ///
    ///   - `ifc_bridge`: The client end of a `WlanSoftmacIfcBridge` server which the
    ///     `wlansoftmac` driver will use to forward `WlanSoftmacIfc` events to
    ///     the bridged driver.
    ///   - `ethernet_tx`: A `ethernet_tx_t*` casted to a `uint64`. The
    ///     `ethernet_tx_t` is defined in
    ///     `//src/connectivity/wlan/drivers/wlansoftmac/rust_driver/c-binding/bindings.h`.
    ///   - `wlan_rx`: A `wlan_rx_t*` casted to a `uint64`. The
    ///     `wlan_rx_t` is defined in
    ///     `//src/connectivity/wlan/drivers/wlansoftmac/rust_driver/c-binding/bindings.h`.
    ///
    /// The server must copy the contents of `ethernet_tx_t` and `wlan_rx_t` before
    /// returning from this method. The lifetimes of `ethernet_tx_t*` and `wlan_rx_t*` are only as
    /// long as this method call, but the contents of `ethernet_tx_t` and `wlan_rx_t` will
    /// live until the server stops the MLME.
    ///
    /// The server returns a server end of a `fuchsia.wlan.mlme/MLME` protocol. The SME
    /// for the iface owns the client end. Thus, this channel is used for SME <-> MLME
    /// communication.
    ///
    /// The `WlanSoftmacBridge.Start` method is different from `WlanSoftmac.Start`
    /// for two reasons. First, Rust bindings do not exist for Driver transported
    /// protocols, so `WlanSoftmacIfcBridge` protocol must be Zircon transported to be
    /// usable by the bridged driver. Second, the Zircon transport adds
    /// significant latency compared to the Driver transport. As a result, the
    /// `ethernet_tx` and `wlan_rx` arguments provide an FFI for the wlansoftmac driver
    /// to send Ethernet and receive WLAN packets to the bridged driver with
    /// latency comparable or better than a Driver transported protocol.
    ///
    /// Except where noted, `WlanSoftmacBridge` methods must only be called after
    /// a successful call to `WlanSoftmacBridge.Start`.
    ///
    /// Common errors include:
    ///
    ///   - `ZX_ERR_ALREADY_BOUND`: `Start` was already called on this softmac.
    pub fn r#start(
        &self,
        mut ifc_bridge: fidl::endpoints::ClientEnd<WlanSoftmacIfcBridgeMarker>,
        mut ethernet_tx: u64,
        mut wlan_rx: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanSoftmacBridgeStartResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBridgeStartRequest,
            fidl::encoding::ResultType<WlanSoftmacBridgeStartResponse, i32>,
            WlanSoftmacBridgeMarker,
        >(
            (ifc_bridge, ethernet_tx, wlan_rx,),
            0x7b2c15a507020d4d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.sme_channel))
    }

    /// Forwards a status containing `ETHERNET_STATUS_*` flags to the
    /// `fuchsia.hardware.ethernet/EthernetImplIfc` proxy owned by
    /// the C++ portion of wlansoftmac.
    ///
    /// As documented, the value of `status` is set by bits defined in
    /// `ETHERNET_STATUS_*` flags. However, there is only one flag named
    /// `ETHERNET_STATUS_ONLINE` and no specification of for the meaning
    /// of specifying no flags. In practice, `0x1` means the status is up,
    /// and `0x0` means the status is down.
    ///
    /// While this method should belong in something like an
    /// "`EthernetImplIfcBridge` protocol", it's included in the
    /// `WlanSoftmacBridge` protocol as a convenience. The wlansoftmac driver
    /// will eventually cease using a `fuchsia.hardware.ethernet/EthernetImplIfc`
    /// proxy and use a `fuchsia.hardware.network.driver/NetworkDeviceIfc`
    /// proxy instead. At that time, an equivalent of this method should be
    /// refactored into a separate bridge.
    pub fn r#set_ethernet_status(
        &self,
        mut status: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacBridgeSetEthernetStatusRequest,
            fidl::encoding::EmptyPayload,
            WlanSoftmacBridgeMarker,
        >(
            (status,),
            0x412503cb3aaa350b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for WlanSoftmacBridgeProxy {
    type Protocol = WlanSoftmacBridgeMarker;

    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 WlanSoftmacBridgeProxy {
    /// Create a new Proxy for fuchsia.wlan.softmac/WlanSoftmacBridge.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <WlanSoftmacBridgeMarker 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) -> WlanSoftmacBridgeEventStream {
        WlanSoftmacBridgeEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets general information about the device and its supported features.
    /// This method is safe to call even when the SoftMAC has not yet started.
    ///
    /// Note: The implementation of this method must not depend on a response
    /// from an ethernet driver, otherwise there is a risk of deadlock.
    /// The wlansoftmac driver calls this method synchronously while
    /// serving the fuchsia.hardware.ethernet/EthernetImpl.Query method.
    pub fn r#query(
        &self,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseQueryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#query(self)
    }

    /// Gets information about the station discovery (e.g., scanning and
    /// probing) features supported by the device. This method is safe to call
    /// even when the SoftMAC has not yet started.
    pub fn r#query_discovery_support(
        &self,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseQueryDiscoverySupportResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#query_discovery_support(self)
    }

    /// Gets information about the MAC features supported by the device. This
    /// method is safe to call even when the SoftMAC has not yet started.
    ///
    /// Note: The implementation of this method must not depend on a response
    /// from an ethernet driver, otherwise there is a risk of deadlock.
    /// The wlansoftmac driver calls this method synchronously while
    /// serving the fuchsia.hardware.ethernet/EthernetImpl.Query method.
    pub fn r#query_mac_sublayer_support(
        &self,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseQueryMacSublayerSupportResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#query_mac_sublayer_support(self)
    }

    /// Gets information about the security features supported by the device.
    /// This method is safe to call even when the SoftMAC has not yet started.
    pub fn r#query_security_support(
        &self,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseQuerySecuritySupportResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#query_security_support(self)
    }

    /// Gets information about the spectrum usage (e.g., DFS) features supported
    /// by the device. This method is safe to call even when the SoftMAC has not
    /// yet started.
    pub fn r#query_spectrum_management_support(
        &self,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseQuerySpectrumManagementSupportResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#query_spectrum_management_support(self)
    }

    /// Set the primary radio channel, e.g. in response to a channel switch event.
    /// If successful, this will trigger the channel switch immediately. This may
    /// impact the transmission of any frames that are in-flight, and might also
    /// interfere with an ongoing scan request.
    ///
    /// Common errors include: \
    ///   ZX_ERR_NOT_SUPPORTED: The device cannot switch to the requested channel.
    pub fn r#set_channel(
        &self,
        mut payload: &WlanSoftmacBaseSetChannelRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseSetChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#set_channel(self, payload)
    }

    /// Join a specific BSS in which we will participate.
    /// This applies regardless of if we are hosting the BSS or joining it
    /// (indicated by the `remote` flag in `JoinBssRequest`).
    /// If successful, the device will switch to the correct channel and perform
    /// any internal filtering/timing operations required to join the BSS.
    /// For client STAs, this is the first step before authenticating.
    ///
    /// Common errors include: \
    ///   ZX_ERR_NOT_SUPPORTED: The device does not support the given bss config.
    pub fn r#join_bss(
        &self,
        mut join_request: &fidl_fuchsia_wlan_driver::JoinBssRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseJoinBssResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#join_bss(self, join_request)
    }

    /// Enables hardware Beaconing.
    ///
    /// This method cannot be called while beaconing is enabled and so
    /// `DisableBeaconing` must be called prior to this method if beaconing is
    /// enabled.
    ///
    /// All request fields are required.
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_NOT_SUPPORTED`: The device does not support hardware beacons.
    /// - `ZX_ERR_INVALID_ARGS`: The device cannot transmit the requested
    ///                          beacon.
    /// - `ZX_ERR_BAD_STATE`: The device is already beaconing.
    pub fn r#enable_beaconing(
        &self,
        mut payload: &WlanSoftmacBaseEnableBeaconingRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseEnableBeaconingResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#enable_beaconing(self, payload)
    }

    /// Disables hardware beaconing.
    pub fn r#disable_beaconing(
        &self,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseDisableBeaconingResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#disable_beaconing(self)
    }

    /// Install a key for encryption when transmitting or receiving protected
    /// frames.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The given config does not specify a valid key.
    ///   ZX_ERR_NOT_SUPPORTED: The device does not support the given cipher.
    pub fn r#install_key(
        &self,
        mut payload: &WlanKeyConfiguration,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseInstallKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#install_key(self, payload)
    }

    /// Notifies the device of a successful association and configures
    /// additional parameters necessary to participate in that association.
    ///
    /// # Errors
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_BAD_STATE`: The device was not previously informed of this BSS
    ///                       via `WlanSoftmac.JoinBss`.
    pub fn r#notify_association_complete(
        &self,
        mut assoc_cfg: &WlanAssociationConfig,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseNotifyAssociationCompleteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#notify_association_complete(self, assoc_cfg)
    }

    /// Notifies MAC and PHY that the peer has been de-associated.
    pub fn r#clear_association(
        &self,
        mut payload: &WlanSoftmacBaseClearAssociationRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseClearAssociationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#clear_association(self, payload)
    }

    /// Starts a passive scan. The server will deliver scan results
    /// as Beacon frames using WlanSoftmacIfc.Recv(). When complete,
    /// the server will call WlanSoftmacIfc.ScanComplete() with the
    /// same `scan_id` returned by StartPassiveScan().
    ///
    /// The server indicates support for `StartPassiveScan()` using
    /// `fuchsia.wlan.common/ScanOffloadExtension.supported`.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The device is not capable of performing the
    ///       requested scan, e.g. because an incompatible channel was requested.
    ///   ZX_ERR_UNAVAILABLE: The device cannot currently perform scans.
    ///   ZX_ERR_SHOULD_WAIT: Another scan is already in-progress.
    pub fn r#start_passive_scan(
        &self,
        mut payload: &WlanSoftmacBaseStartPassiveScanRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseStartPassiveScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#start_passive_scan(self, payload)
    }

    /// Starts an active scan. The server will deliver scan results
    /// as Beacon or Probe Response frames using WlanSoftmacIfc.Recv().
    /// When complete, the server will call WlanSoftmacIfc.ScanComplete()
    /// with the same `scan_id` returned by StartActiveScan().
    ///
    /// A device driver indicates support for `StartActiveScan()` using
    /// `fuchsia.wlan.common/ProbeRequestOffloadExtension.supported`.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The device is not capable of performing the
    ///       requested scan, e.g. because an incompatible channel was requested.
    ///   ZX_ERR_UNAVAILABLE: The device cannot currently perform scans.
    ///   ZX_ERR_SHOULD_WAIT: Another scan is already in-progress.
    pub fn r#start_active_scan(
        &self,
        mut payload: &WlanSoftmacStartActiveScanRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseStartActiveScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#start_active_scan(self, payload)
    }

    /// Cancels the ongoing scan corresponding to `scan_id`,
    /// where `scan_id` is an identifier returned by
    /// `StartPassiveScan()` or `StartActiveScan()`. If cancellation succeeds,
    /// the server will soon call WlanSoftmacIfc.ScanComplete() with the same
    /// `scan_id`.
    ///
    /// A device driver indicates support for `CancelScan()` using
    /// `fuchsia.wlan.common/ScanOffloadExtension.scan_cancel_supported`.
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_NOT_FOUND`: `scan_id` does not match an ongoing scan.
    /// - `ZX_ERR_NOT_SUPPORTED`: Server does not support scan cancellation.
    pub fn r#cancel_scan(
        &self,
        mut payload: &WlanSoftmacBaseCancelScanRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseCancelScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#cancel_scan(self, payload)
    }

    /// Indicate the device of modified WiFi Multimedia (WMM) parameters for a
    /// particular access category (AC).
    pub fn r#update_wmm_parameters(
        &self,
        mut payload: &WlanSoftmacBaseUpdateWmmParametersRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBaseUpdateWmmParametersResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#update_wmm_parameters(self, payload)
    }

    /// Signal to the server that the MLME for the iface is ready to send and receive
    /// frames.
    ///
    /// The client provides the following arguments:
    ///
    ///   - `ifc_bridge`: The client end of a `WlanSoftmacIfcBridge` server which the
    ///     `wlansoftmac` driver will use to forward `WlanSoftmacIfc` events to
    ///     the bridged driver.
    ///   - `ethernet_tx`: A `ethernet_tx_t*` casted to a `uint64`. The
    ///     `ethernet_tx_t` is defined in
    ///     `//src/connectivity/wlan/drivers/wlansoftmac/rust_driver/c-binding/bindings.h`.
    ///   - `wlan_rx`: A `wlan_rx_t*` casted to a `uint64`. The
    ///     `wlan_rx_t` is defined in
    ///     `//src/connectivity/wlan/drivers/wlansoftmac/rust_driver/c-binding/bindings.h`.
    ///
    /// The server must copy the contents of `ethernet_tx_t` and `wlan_rx_t` before
    /// returning from this method. The lifetimes of `ethernet_tx_t*` and `wlan_rx_t*` are only as
    /// long as this method call, but the contents of `ethernet_tx_t` and `wlan_rx_t` will
    /// live until the server stops the MLME.
    ///
    /// The server returns a server end of a `fuchsia.wlan.mlme/MLME` protocol. The SME
    /// for the iface owns the client end. Thus, this channel is used for SME <-> MLME
    /// communication.
    ///
    /// The `WlanSoftmacBridge.Start` method is different from `WlanSoftmac.Start`
    /// for two reasons. First, Rust bindings do not exist for Driver transported
    /// protocols, so `WlanSoftmacIfcBridge` protocol must be Zircon transported to be
    /// usable by the bridged driver. Second, the Zircon transport adds
    /// significant latency compared to the Driver transport. As a result, the
    /// `ethernet_tx` and `wlan_rx` arguments provide an FFI for the wlansoftmac driver
    /// to send Ethernet and receive WLAN packets to the bridged driver with
    /// latency comparable or better than a Driver transported protocol.
    ///
    /// Except where noted, `WlanSoftmacBridge` methods must only be called after
    /// a successful call to `WlanSoftmacBridge.Start`.
    ///
    /// Common errors include:
    ///
    ///   - `ZX_ERR_ALREADY_BOUND`: `Start` was already called on this softmac.
    pub fn r#start(
        &self,
        mut ifc_bridge: fidl::endpoints::ClientEnd<WlanSoftmacIfcBridgeMarker>,
        mut ethernet_tx: u64,
        mut wlan_rx: u64,
    ) -> fidl::client::QueryResponseFut<
        WlanSoftmacBridgeStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanSoftmacBridgeProxyInterface::r#start(self, ifc_bridge, ethernet_tx, wlan_rx)
    }

    /// Forwards a status containing `ETHERNET_STATUS_*` flags to the
    /// `fuchsia.hardware.ethernet/EthernetImplIfc` proxy owned by
    /// the C++ portion of wlansoftmac.
    ///
    /// As documented, the value of `status` is set by bits defined in
    /// `ETHERNET_STATUS_*` flags. However, there is only one flag named
    /// `ETHERNET_STATUS_ONLINE` and no specification of for the meaning
    /// of specifying no flags. In practice, `0x1` means the status is up,
    /// and `0x0` means the status is down.
    ///
    /// While this method should belong in something like an
    /// "`EthernetImplIfcBridge` protocol", it's included in the
    /// `WlanSoftmacBridge` protocol as a convenience. The wlansoftmac driver
    /// will eventually cease using a `fuchsia.hardware.ethernet/EthernetImplIfc`
    /// proxy and use a `fuchsia.hardware.network.driver/NetworkDeviceIfc`
    /// proxy instead. At that time, an equivalent of this method should be
    /// refactored into a separate bridge.
    pub fn r#set_ethernet_status(
        &self,
        mut status: u32,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        WlanSoftmacBridgeProxyInterface::r#set_ethernet_status(self, status)
    }
}

impl WlanSoftmacBridgeProxyInterface for WlanSoftmacBridgeProxy {
    type QueryResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseQueryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query(&self) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseQueryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<WlanSoftmacQueryResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x18231a638e508f9d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, WlanSoftmacBaseQueryResult>(
                (),
                0x18231a638e508f9d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

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

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

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

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

    type SetChannelResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseSetChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_channel(
        &self,
        mut payload: &WlanSoftmacBaseSetChannelRequest,
    ) -> Self::SetChannelResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseSetChannelResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x12836b533cd63ece,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacBaseSetChannelRequest,
            WlanSoftmacBaseSetChannelResult,
        >(
            payload,
            0x12836b533cd63ece,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type JoinBssResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseJoinBssResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#join_bss(
        &self,
        mut join_request: &fidl_fuchsia_wlan_driver::JoinBssRequest,
    ) -> Self::JoinBssResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseJoinBssResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1336fb5455b77a6e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<WlanSoftmacBaseJoinBssRequest, WlanSoftmacBaseJoinBssResult>(
                (join_request,),
                0x1336fb5455b77a6e,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type EnableBeaconingResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseEnableBeaconingResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#enable_beaconing(
        &self,
        mut payload: &WlanSoftmacBaseEnableBeaconingRequest,
    ) -> Self::EnableBeaconingResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseEnableBeaconingResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6c35807632c64576,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacBaseEnableBeaconingRequest,
            WlanSoftmacBaseEnableBeaconingResult,
        >(
            payload,
            0x6c35807632c64576,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type InstallKeyResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseInstallKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#install_key(&self, mut payload: &WlanKeyConfiguration) -> Self::InstallKeyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseInstallKeyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7decf9b4200b9131,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<WlanKeyConfiguration, WlanSoftmacBaseInstallKeyResult>(
            payload,
            0x7decf9b4200b9131,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type NotifyAssociationCompleteResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseNotifyAssociationCompleteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#notify_association_complete(
        &self,
        mut assoc_cfg: &WlanAssociationConfig,
    ) -> Self::NotifyAssociationCompleteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseNotifyAssociationCompleteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x436ffe3ba461d6cd,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacBaseNotifyAssociationCompleteRequest,
            WlanSoftmacBaseNotifyAssociationCompleteResult,
        >(
            (assoc_cfg,),
            0x436ffe3ba461d6cd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ClearAssociationResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseClearAssociationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#clear_association(
        &self,
        mut payload: &WlanSoftmacBaseClearAssociationRequest,
    ) -> Self::ClearAssociationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseClearAssociationResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x581d76c39190a7dd,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacBaseClearAssociationRequest,
            WlanSoftmacBaseClearAssociationResult,
        >(
            payload,
            0x581d76c39190a7dd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartPassiveScanResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseStartPassiveScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start_passive_scan(
        &self,
        mut payload: &WlanSoftmacBaseStartPassiveScanRequest,
    ) -> Self::StartPassiveScanResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseStartPassiveScanResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<WlanSoftmacBaseStartPassiveScanResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5662f989cb4083bb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacBaseStartPassiveScanRequest,
            WlanSoftmacBaseStartPassiveScanResult,
        >(
            payload,
            0x5662f989cb4083bb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartActiveScanResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseStartActiveScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start_active_scan(
        &self,
        mut payload: &WlanSoftmacStartActiveScanRequest,
    ) -> Self::StartActiveScanResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseStartActiveScanResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<WlanSoftmacBaseStartActiveScanResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4896eafa9937751e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacStartActiveScanRequest,
            WlanSoftmacBaseStartActiveScanResult,
        >(
            payload,
            0x4896eafa9937751e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CancelScanResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseCancelScanResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#cancel_scan(
        &self,
        mut payload: &WlanSoftmacBaseCancelScanRequest,
    ) -> Self::CancelScanResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseCancelScanResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xf7d859369764556,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacBaseCancelScanRequest,
            WlanSoftmacBaseCancelScanResult,
        >(
            payload,
            0xf7d859369764556,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UpdateWmmParametersResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBaseUpdateWmmParametersResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#update_wmm_parameters(
        &self,
        mut payload: &WlanSoftmacBaseUpdateWmmParametersRequest,
    ) -> Self::UpdateWmmParametersResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBaseUpdateWmmParametersResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x68522c7122d5f78c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            WlanSoftmacBaseUpdateWmmParametersRequest,
            WlanSoftmacBaseUpdateWmmParametersResult,
        >(
            payload,
            0x68522c7122d5f78c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartResponseFut = fidl::client::QueryResponseFut<
        WlanSoftmacBridgeStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start(
        &self,
        mut ifc_bridge: fidl::endpoints::ClientEnd<WlanSoftmacIfcBridgeMarker>,
        mut ethernet_tx: u64,
        mut wlan_rx: u64,
    ) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanSoftmacBridgeStartResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<WlanSoftmacBridgeStartResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7b2c15a507020d4d,
            >(_buf?)?;
            Ok(_response.map(|x| x.sme_channel))
        }
        self.client
            .send_query_and_decode::<WlanSoftmacBridgeStartRequest, WlanSoftmacBridgeStartResult>(
                (ifc_bridge, ethernet_tx, wlan_rx),
                0x7b2c15a507020d4d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetEthernetStatusResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_ethernet_status(&self, mut status: u32) -> Self::SetEthernetStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x412503cb3aaa350b,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<WlanSoftmacBridgeSetEthernetStatusRequest, ()>(
            (status,),
            0x412503cb3aaa350b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for WlanSoftmacBridgeEventStream {
    type Item = Result<WlanSoftmacBridgeEvent, 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(WlanSoftmacBridgeEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum WlanSoftmacBridgeEvent {
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl WlanSoftmacBridgeEvent {
    /// Decodes a message buffer as a [`WlanSoftmacBridgeEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<WlanSoftmacBridgeEvent, 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 {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(WlanSoftmacBridgeEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <WlanSoftmacBridgeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for WlanSoftmacBridgeRequestStream {
    type Protocol = WlanSoftmacBridgeMarker;
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    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 {
        WlanSoftmacBridgeControlHandle { 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 WlanSoftmacBridgeRequestStream {
    type Item = Result<WlanSoftmacBridgeRequest, 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 WlanSoftmacBridgeRequestStream 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 {
                    0x18231a638e508f9d => {
                        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 =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::Query {
                            responder: WlanSoftmacBridgeQueryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x16797affc0cb58ae => {
                        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 =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::QueryDiscoverySupport {
                            responder: WlanSoftmacBridgeQueryDiscoverySupportResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7302c3f8c131f075 => {
                        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 =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::QueryMacSublayerSupport {
                            responder: WlanSoftmacBridgeQueryMacSublayerSupportResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3691bb75abf6354 => {
                        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 =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::QuerySecuritySupport {
                            responder: WlanSoftmacBridgeQuerySecuritySupportResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x347d78dc1d4d27bf => {
                        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 =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::QuerySpectrumManagementSupport {
                            responder: WlanSoftmacBridgeQuerySpectrumManagementSupportResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x12836b533cd63ece => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseSetChannelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseSetChannelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::SetChannel {
                            payload: req,
                            responder: WlanSoftmacBridgeSetChannelResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1336fb5455b77a6e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseJoinBssRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseJoinBssRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::JoinBss {
                            join_request: req.join_request,

                            responder: WlanSoftmacBridgeJoinBssResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6c35807632c64576 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseEnableBeaconingRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseEnableBeaconingRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::EnableBeaconing {
                            payload: req,
                            responder: WlanSoftmacBridgeEnableBeaconingResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3303b30f99dbb406 => {
                        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 =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::DisableBeaconing {
                            responder: WlanSoftmacBridgeDisableBeaconingResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7decf9b4200b9131 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanKeyConfiguration,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanKeyConfiguration>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::InstallKey {
                            payload: req,
                            responder: WlanSoftmacBridgeInstallKeyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x436ffe3ba461d6cd => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseNotifyAssociationCompleteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseNotifyAssociationCompleteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::NotifyAssociationComplete {
                            assoc_cfg: req.assoc_cfg,

                            responder: WlanSoftmacBridgeNotifyAssociationCompleteResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x581d76c39190a7dd => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseClearAssociationRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseClearAssociationRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::ClearAssociation {
                            payload: req,
                            responder: WlanSoftmacBridgeClearAssociationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5662f989cb4083bb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseStartPassiveScanRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseStartPassiveScanRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::StartPassiveScan {
                            payload: req,
                            responder: WlanSoftmacBridgeStartPassiveScanResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4896eafa9937751e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacStartActiveScanRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacStartActiveScanRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::StartActiveScan {
                            payload: req,
                            responder: WlanSoftmacBridgeStartActiveScanResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xf7d859369764556 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseCancelScanRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseCancelScanRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::CancelScan {
                            payload: req,
                            responder: WlanSoftmacBridgeCancelScanResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x68522c7122d5f78c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBaseUpdateWmmParametersRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBaseUpdateWmmParametersRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::UpdateWmmParameters {
                            payload: req,
                            responder: WlanSoftmacBridgeUpdateWmmParametersResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7b2c15a507020d4d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBridgeStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBridgeStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::Start {
                            ifc_bridge: req.ifc_bridge,
                            ethernet_tx: req.ethernet_tx,
                            wlan_rx: req.wlan_rx,

                            responder: WlanSoftmacBridgeStartResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x412503cb3aaa350b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanSoftmacBridgeSetEthernetStatusRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacBridgeSetEthernetStatusRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            WlanSoftmacBridgeControlHandle { inner: this.inner.clone() };
                        Ok(WlanSoftmacBridgeRequest::SetEthernetStatus {
                            status: req.status,

                            responder: WlanSoftmacBridgeSetEthernetStatusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(WlanSoftmacBridgeRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: WlanSoftmacBridgeControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::OneWay,
                        })
                    }
                    _ if header
                        .dynamic_flags()
                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        this.inner.send_framework_err(
                            fidl::encoding::FrameworkErr::UnknownMethod,
                            header.tx_id,
                            header.ordinal,
                            header.dynamic_flags(),
                            (bytes, handles),
                        )?;
                        Ok(WlanSoftmacBridgeRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: WlanSoftmacBridgeControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <WlanSoftmacBridgeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// `WlanSoftmacBridge` is the protocol the `wlansoftmac` driver serves
/// to the bridged driver. This protocol **should not** be implemented
/// by a vendor driver.
#[derive(Debug)]
pub enum WlanSoftmacBridgeRequest {
    /// Gets general information about the device and its supported features.
    /// This method is safe to call even when the SoftMAC has not yet started.
    ///
    /// Note: The implementation of this method must not depend on a response
    /// from an ethernet driver, otherwise there is a risk of deadlock.
    /// The wlansoftmac driver calls this method synchronously while
    /// serving the fuchsia.hardware.ethernet/EthernetImpl.Query method.
    Query { responder: WlanSoftmacBridgeQueryResponder },
    /// Gets information about the station discovery (e.g., scanning and
    /// probing) features supported by the device. This method is safe to call
    /// even when the SoftMAC has not yet started.
    QueryDiscoverySupport { responder: WlanSoftmacBridgeQueryDiscoverySupportResponder },
    /// Gets information about the MAC features supported by the device. This
    /// method is safe to call even when the SoftMAC has not yet started.
    ///
    /// Note: The implementation of this method must not depend on a response
    /// from an ethernet driver, otherwise there is a risk of deadlock.
    /// The wlansoftmac driver calls this method synchronously while
    /// serving the fuchsia.hardware.ethernet/EthernetImpl.Query method.
    QueryMacSublayerSupport { responder: WlanSoftmacBridgeQueryMacSublayerSupportResponder },
    /// Gets information about the security features supported by the device.
    /// This method is safe to call even when the SoftMAC has not yet started.
    QuerySecuritySupport { responder: WlanSoftmacBridgeQuerySecuritySupportResponder },
    /// Gets information about the spectrum usage (e.g., DFS) features supported
    /// by the device. This method is safe to call even when the SoftMAC has not
    /// yet started.
    QuerySpectrumManagementSupport {
        responder: WlanSoftmacBridgeQuerySpectrumManagementSupportResponder,
    },
    /// Set the primary radio channel, e.g. in response to a channel switch event.
    /// If successful, this will trigger the channel switch immediately. This may
    /// impact the transmission of any frames that are in-flight, and might also
    /// interfere with an ongoing scan request.
    ///
    /// Common errors include: \
    ///   ZX_ERR_NOT_SUPPORTED: The device cannot switch to the requested channel.
    SetChannel {
        payload: WlanSoftmacBaseSetChannelRequest,
        responder: WlanSoftmacBridgeSetChannelResponder,
    },
    /// Join a specific BSS in which we will participate.
    /// This applies regardless of if we are hosting the BSS or joining it
    /// (indicated by the `remote` flag in `JoinBssRequest`).
    /// If successful, the device will switch to the correct channel and perform
    /// any internal filtering/timing operations required to join the BSS.
    /// For client STAs, this is the first step before authenticating.
    ///
    /// Common errors include: \
    ///   ZX_ERR_NOT_SUPPORTED: The device does not support the given bss config.
    JoinBss {
        join_request: fidl_fuchsia_wlan_driver::JoinBssRequest,
        responder: WlanSoftmacBridgeJoinBssResponder,
    },
    /// Enables hardware Beaconing.
    ///
    /// This method cannot be called while beaconing is enabled and so
    /// `DisableBeaconing` must be called prior to this method if beaconing is
    /// enabled.
    ///
    /// All request fields are required.
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_NOT_SUPPORTED`: The device does not support hardware beacons.
    /// - `ZX_ERR_INVALID_ARGS`: The device cannot transmit the requested
    ///                          beacon.
    /// - `ZX_ERR_BAD_STATE`: The device is already beaconing.
    EnableBeaconing {
        payload: WlanSoftmacBaseEnableBeaconingRequest,
        responder: WlanSoftmacBridgeEnableBeaconingResponder,
    },
    /// Disables hardware beaconing.
    DisableBeaconing { responder: WlanSoftmacBridgeDisableBeaconingResponder },
    /// Install a key for encryption when transmitting or receiving protected
    /// frames.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The given config does not specify a valid key.
    ///   ZX_ERR_NOT_SUPPORTED: The device does not support the given cipher.
    InstallKey { payload: WlanKeyConfiguration, responder: WlanSoftmacBridgeInstallKeyResponder },
    /// Notifies the device of a successful association and configures
    /// additional parameters necessary to participate in that association.
    ///
    /// # Errors
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_BAD_STATE`: The device was not previously informed of this BSS
    ///                       via `WlanSoftmac.JoinBss`.
    NotifyAssociationComplete {
        assoc_cfg: WlanAssociationConfig,
        responder: WlanSoftmacBridgeNotifyAssociationCompleteResponder,
    },
    /// Notifies MAC and PHY that the peer has been de-associated.
    ClearAssociation {
        payload: WlanSoftmacBaseClearAssociationRequest,
        responder: WlanSoftmacBridgeClearAssociationResponder,
    },
    /// Starts a passive scan. The server will deliver scan results
    /// as Beacon frames using WlanSoftmacIfc.Recv(). When complete,
    /// the server will call WlanSoftmacIfc.ScanComplete() with the
    /// same `scan_id` returned by StartPassiveScan().
    ///
    /// The server indicates support for `StartPassiveScan()` using
    /// `fuchsia.wlan.common/ScanOffloadExtension.supported`.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The device is not capable of performing the
    ///       requested scan, e.g. because an incompatible channel was requested.
    ///   ZX_ERR_UNAVAILABLE: The device cannot currently perform scans.
    ///   ZX_ERR_SHOULD_WAIT: Another scan is already in-progress.
    StartPassiveScan {
        payload: WlanSoftmacBaseStartPassiveScanRequest,
        responder: WlanSoftmacBridgeStartPassiveScanResponder,
    },
    /// Starts an active scan. The server will deliver scan results
    /// as Beacon or Probe Response frames using WlanSoftmacIfc.Recv().
    /// When complete, the server will call WlanSoftmacIfc.ScanComplete()
    /// with the same `scan_id` returned by StartActiveScan().
    ///
    /// A device driver indicates support for `StartActiveScan()` using
    /// `fuchsia.wlan.common/ProbeRequestOffloadExtension.supported`.
    ///
    /// Common errors include:
    ///   ZX_ERR_INVALID_ARGS: The device is not capable of performing the
    ///       requested scan, e.g. because an incompatible channel was requested.
    ///   ZX_ERR_UNAVAILABLE: The device cannot currently perform scans.
    ///   ZX_ERR_SHOULD_WAIT: Another scan is already in-progress.
    StartActiveScan {
        payload: WlanSoftmacStartActiveScanRequest,
        responder: WlanSoftmacBridgeStartActiveScanResponder,
    },
    /// Cancels the ongoing scan corresponding to `scan_id`,
    /// where `scan_id` is an identifier returned by
    /// `StartPassiveScan()` or `StartActiveScan()`. If cancellation succeeds,
    /// the server will soon call WlanSoftmacIfc.ScanComplete() with the same
    /// `scan_id`.
    ///
    /// A device driver indicates support for `CancelScan()` using
    /// `fuchsia.wlan.common/ScanOffloadExtension.scan_cancel_supported`.
    ///
    /// Common errors include:
    ///
    /// - `ZX_ERR_NOT_FOUND`: `scan_id` does not match an ongoing scan.
    /// - `ZX_ERR_NOT_SUPPORTED`: Server does not support scan cancellation.
    CancelScan {
        payload: WlanSoftmacBaseCancelScanRequest,
        responder: WlanSoftmacBridgeCancelScanResponder,
    },
    /// Indicate the device of modified WiFi Multimedia (WMM) parameters for a
    /// particular access category (AC).
    UpdateWmmParameters {
        payload: WlanSoftmacBaseUpdateWmmParametersRequest,
        responder: WlanSoftmacBridgeUpdateWmmParametersResponder,
    },
    /// Signal to the server that the MLME for the iface is ready to send and receive
    /// frames.
    ///
    /// The client provides the following arguments:
    ///
    ///   - `ifc_bridge`: The client end of a `WlanSoftmacIfcBridge` server which the
    ///     `wlansoftmac` driver will use to forward `WlanSoftmacIfc` events to
    ///     the bridged driver.
    ///   - `ethernet_tx`: A `ethernet_tx_t*` casted to a `uint64`. The
    ///     `ethernet_tx_t` is defined in
    ///     `//src/connectivity/wlan/drivers/wlansoftmac/rust_driver/c-binding/bindings.h`.
    ///   - `wlan_rx`: A `wlan_rx_t*` casted to a `uint64`. The
    ///     `wlan_rx_t` is defined in
    ///     `//src/connectivity/wlan/drivers/wlansoftmac/rust_driver/c-binding/bindings.h`.
    ///
    /// The server must copy the contents of `ethernet_tx_t` and `wlan_rx_t` before
    /// returning from this method. The lifetimes of `ethernet_tx_t*` and `wlan_rx_t*` are only as
    /// long as this method call, but the contents of `ethernet_tx_t` and `wlan_rx_t` will
    /// live until the server stops the MLME.
    ///
    /// The server returns a server end of a `fuchsia.wlan.mlme/MLME` protocol. The SME
    /// for the iface owns the client end. Thus, this channel is used for SME <-> MLME
    /// communication.
    ///
    /// The `WlanSoftmacBridge.Start` method is different from `WlanSoftmac.Start`
    /// for two reasons. First, Rust bindings do not exist for Driver transported
    /// protocols, so `WlanSoftmacIfcBridge` protocol must be Zircon transported to be
    /// usable by the bridged driver. Second, the Zircon transport adds
    /// significant latency compared to the Driver transport. As a result, the
    /// `ethernet_tx` and `wlan_rx` arguments provide an FFI for the wlansoftmac driver
    /// to send Ethernet and receive WLAN packets to the bridged driver with
    /// latency comparable or better than a Driver transported protocol.
    ///
    /// Except where noted, `WlanSoftmacBridge` methods must only be called after
    /// a successful call to `WlanSoftmacBridge.Start`.
    ///
    /// Common errors include:
    ///
    ///   - `ZX_ERR_ALREADY_BOUND`: `Start` was already called on this softmac.
    Start {
        ifc_bridge: fidl::endpoints::ClientEnd<WlanSoftmacIfcBridgeMarker>,
        ethernet_tx: u64,
        wlan_rx: u64,
        responder: WlanSoftmacBridgeStartResponder,
    },
    /// Forwards a status containing `ETHERNET_STATUS_*` flags to the
    /// `fuchsia.hardware.ethernet/EthernetImplIfc` proxy owned by
    /// the C++ portion of wlansoftmac.
    ///
    /// As documented, the value of `status` is set by bits defined in
    /// `ETHERNET_STATUS_*` flags. However, there is only one flag named
    /// `ETHERNET_STATUS_ONLINE` and no specification of for the meaning
    /// of specifying no flags. In practice, `0x1` means the status is up,
    /// and `0x0` means the status is down.
    ///
    /// While this method should belong in something like an
    /// "`EthernetImplIfcBridge` protocol", it's included in the
    /// `WlanSoftmacBridge` protocol as a convenience. The wlansoftmac driver
    /// will eventually cease using a `fuchsia.hardware.ethernet/EthernetImplIfc`
    /// proxy and use a `fuchsia.hardware.network.driver/NetworkDeviceIfc`
    /// proxy instead. At that time, an equivalent of this method should be
    /// refactored into a separate bridge.
    SetEthernetStatus { status: u32, responder: WlanSoftmacBridgeSetEthernetStatusResponder },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: WlanSoftmacBridgeControlHandle,
        method_type: fidl::MethodType,
    },
}

impl WlanSoftmacBridgeRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_query(self) -> Option<(WlanSoftmacBridgeQueryResponder)> {
        if let WlanSoftmacBridgeRequest::Query { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_discovery_support(
        self,
    ) -> Option<(WlanSoftmacBridgeQueryDiscoverySupportResponder)> {
        if let WlanSoftmacBridgeRequest::QueryDiscoverySupport { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_mac_sublayer_support(
        self,
    ) -> Option<(WlanSoftmacBridgeQueryMacSublayerSupportResponder)> {
        if let WlanSoftmacBridgeRequest::QueryMacSublayerSupport { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_security_support(
        self,
    ) -> Option<(WlanSoftmacBridgeQuerySecuritySupportResponder)> {
        if let WlanSoftmacBridgeRequest::QuerySecuritySupport { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_spectrum_management_support(
        self,
    ) -> Option<(WlanSoftmacBridgeQuerySpectrumManagementSupportResponder)> {
        if let WlanSoftmacBridgeRequest::QuerySpectrumManagementSupport { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_channel(
        self,
    ) -> Option<(WlanSoftmacBaseSetChannelRequest, WlanSoftmacBridgeSetChannelResponder)> {
        if let WlanSoftmacBridgeRequest::SetChannel { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_join_bss(
        self,
    ) -> Option<(fidl_fuchsia_wlan_driver::JoinBssRequest, WlanSoftmacBridgeJoinBssResponder)> {
        if let WlanSoftmacBridgeRequest::JoinBss { join_request, responder } = self {
            Some((join_request, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_enable_beaconing(
        self,
    ) -> Option<(WlanSoftmacBaseEnableBeaconingRequest, WlanSoftmacBridgeEnableBeaconingResponder)>
    {
        if let WlanSoftmacBridgeRequest::EnableBeaconing { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_disable_beaconing(self) -> Option<(WlanSoftmacBridgeDisableBeaconingResponder)> {
        if let WlanSoftmacBridgeRequest::DisableBeaconing { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_install_key(
        self,
    ) -> Option<(WlanKeyConfiguration, WlanSoftmacBridgeInstallKeyResponder)> {
        if let WlanSoftmacBridgeRequest::InstallKey { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_association_complete(
        self,
    ) -> Option<(WlanAssociationConfig, WlanSoftmacBridgeNotifyAssociationCompleteResponder)> {
        if let WlanSoftmacBridgeRequest::NotifyAssociationComplete { assoc_cfg, responder } = self {
            Some((assoc_cfg, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clear_association(
        self,
    ) -> Option<(WlanSoftmacBaseClearAssociationRequest, WlanSoftmacBridgeClearAssociationResponder)>
    {
        if let WlanSoftmacBridgeRequest::ClearAssociation { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start_passive_scan(
        self,
    ) -> Option<(WlanSoftmacBaseStartPassiveScanRequest, WlanSoftmacBridgeStartPassiveScanResponder)>
    {
        if let WlanSoftmacBridgeRequest::StartPassiveScan { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start_active_scan(
        self,
    ) -> Option<(WlanSoftmacStartActiveScanRequest, WlanSoftmacBridgeStartActiveScanResponder)>
    {
        if let WlanSoftmacBridgeRequest::StartActiveScan { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_cancel_scan(
        self,
    ) -> Option<(WlanSoftmacBaseCancelScanRequest, WlanSoftmacBridgeCancelScanResponder)> {
        if let WlanSoftmacBridgeRequest::CancelScan { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_update_wmm_parameters(
        self,
    ) -> Option<(
        WlanSoftmacBaseUpdateWmmParametersRequest,
        WlanSoftmacBridgeUpdateWmmParametersResponder,
    )> {
        if let WlanSoftmacBridgeRequest::UpdateWmmParameters { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<WlanSoftmacIfcBridgeMarker>,
        u64,
        u64,
        WlanSoftmacBridgeStartResponder,
    )> {
        if let WlanSoftmacBridgeRequest::Start { ifc_bridge, ethernet_tx, wlan_rx, responder } =
            self
        {
            Some((ifc_bridge, ethernet_tx, wlan_rx, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ethernet_status(
        self,
    ) -> Option<(u32, WlanSoftmacBridgeSetEthernetStatusResponder)> {
        if let WlanSoftmacBridgeRequest::SetEthernetStatus { status, responder } = self {
            Some((status, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            WlanSoftmacBridgeRequest::Query { .. } => "query",
            WlanSoftmacBridgeRequest::QueryDiscoverySupport { .. } => "query_discovery_support",
            WlanSoftmacBridgeRequest::QueryMacSublayerSupport { .. } => {
                "query_mac_sublayer_support"
            }
            WlanSoftmacBridgeRequest::QuerySecuritySupport { .. } => "query_security_support",
            WlanSoftmacBridgeRequest::QuerySpectrumManagementSupport { .. } => {
                "query_spectrum_management_support"
            }
            WlanSoftmacBridgeRequest::SetChannel { .. } => "set_channel",
            WlanSoftmacBridgeRequest::JoinBss { .. } => "join_bss",
            WlanSoftmacBridgeRequest::EnableBeaconing { .. } => "enable_beaconing",
            WlanSoftmacBridgeRequest::DisableBeaconing { .. } => "disable_beaconing",
            WlanSoftmacBridgeRequest::InstallKey { .. } => "install_key",
            WlanSoftmacBridgeRequest::NotifyAssociationComplete { .. } => {
                "notify_association_complete"
            }
            WlanSoftmacBridgeRequest::ClearAssociation { .. } => "clear_association",
            WlanSoftmacBridgeRequest::StartPassiveScan { .. } => "start_passive_scan",
            WlanSoftmacBridgeRequest::StartActiveScan { .. } => "start_active_scan",
            WlanSoftmacBridgeRequest::CancelScan { .. } => "cancel_scan",
            WlanSoftmacBridgeRequest::UpdateWmmParameters { .. } => "update_wmm_parameters",
            WlanSoftmacBridgeRequest::Start { .. } => "start",
            WlanSoftmacBridgeRequest::SetEthernetStatus { .. } => "set_ethernet_status",
            WlanSoftmacBridgeRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay,
                ..
            } => "unknown one-way method",
            WlanSoftmacBridgeRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay,
                ..
            } => "unknown two-way method",
        }
    }
}

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

impl WlanSoftmacBridgeControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 WlanSoftmacBridgeControlHandle {}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeQueryResponder {
    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 WlanSoftmacBridgeQueryResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeQueryResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&WlanSoftmacQueryResponse, 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<&WlanSoftmacQueryResponse, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeQueryDiscoverySupportResponder {
    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 WlanSoftmacBridgeQueryDiscoverySupportResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeQueryDiscoverySupportResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<&DiscoverySupport, 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<&DiscoverySupport, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeQueryMacSublayerSupportResponder {
    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 WlanSoftmacBridgeQueryMacSublayerSupportResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeQueryMacSublayerSupportResponder {
    /// 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_common::MacSublayerSupport, 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_common::MacSublayerSupport, 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_common::MacSublayerSupport, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            WlanSoftmacBaseQueryMacSublayerSupportResponse,
            i32,
        >>(
            result.map(|resp| (resp,)),
            self.tx_id,
            0x7302c3f8c131f075,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeQuerySecuritySupportResponder {
    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 WlanSoftmacBridgeQuerySecuritySupportResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeQuerySecuritySupportResponder {
    /// 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_common::SecuritySupport, 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_common::SecuritySupport, 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_common::SecuritySupport, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            WlanSoftmacBaseQuerySecuritySupportResponse,
            i32,
        >>(
            result.map(|resp| (resp,)),
            self.tx_id,
            0x3691bb75abf6354,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeQuerySpectrumManagementSupportResponder {
    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 WlanSoftmacBridgeQuerySpectrumManagementSupportResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeQuerySpectrumManagementSupportResponder {
    /// 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_common::SpectrumManagementSupport, 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_common::SpectrumManagementSupport, 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_common::SpectrumManagementSupport, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            WlanSoftmacBaseQuerySpectrumManagementSupportResponse,
            i32,
        >>(
            result.map(|resp| (resp,)),
            self.tx_id,
            0x347d78dc1d4d27bf,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeSetChannelResponder {
    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 WlanSoftmacBridgeSetChannelResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeSetChannelResponder {
    /// 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,
                0x12836b533cd63ece,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeJoinBssResponder {
    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 WlanSoftmacBridgeJoinBssResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeJoinBssResponder {
    /// 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,
                0x1336fb5455b77a6e,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeEnableBeaconingResponder {
    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 WlanSoftmacBridgeEnableBeaconingResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeEnableBeaconingResponder {
    /// 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,
                0x6c35807632c64576,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeDisableBeaconingResponder {
    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 WlanSoftmacBridgeDisableBeaconingResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeDisableBeaconingResponder {
    /// 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,
                0x3303b30f99dbb406,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeInstallKeyResponder {
    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 WlanSoftmacBridgeInstallKeyResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeInstallKeyResponder {
    /// 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,
                0x7decf9b4200b9131,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeNotifyAssociationCompleteResponder {
    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 WlanSoftmacBridgeNotifyAssociationCompleteResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeNotifyAssociationCompleteResponder {
    /// 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,
                0x436ffe3ba461d6cd,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeClearAssociationResponder {
    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 WlanSoftmacBridgeClearAssociationResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeClearAssociationResponder {
    /// 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,
                0x581d76c39190a7dd,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeStartPassiveScanResponder {
    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 WlanSoftmacBridgeStartPassiveScanResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeStartPassiveScanResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&WlanSoftmacBaseStartPassiveScanResponse, 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<&WlanSoftmacBaseStartPassiveScanResponse, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeStartActiveScanResponder {
    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 WlanSoftmacBridgeStartActiveScanResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeStartActiveScanResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&WlanSoftmacBaseStartActiveScanResponse, 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<&WlanSoftmacBaseStartActiveScanResponse, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

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

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeCancelScanResponder {
    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 WlanSoftmacBridgeCancelScanResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeCancelScanResponder {
    /// 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,
                0xf7d859369764556,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeUpdateWmmParametersResponder {
    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 WlanSoftmacBridgeUpdateWmmParametersResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeUpdateWmmParametersResponder {
    /// 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,
                0x68522c7122d5f78c,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeStartResponder {
    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 WlanSoftmacBridgeStartResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeStartResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<fidl::Channel, 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::Channel, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<fidl::Channel, i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<WlanSoftmacBridgeStartResponse, i32>>(
                result.map(|sme_channel| (sme_channel,)),
                self.tx_id,
                0x7b2c15a507020d4d,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacBridgeControlHandle::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 WlanSoftmacBridgeSetEthernetStatusResponder {
    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 WlanSoftmacBridgeSetEthernetStatusResponder {
    type ControlHandle = WlanSoftmacBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacBridgeControlHandle {
        &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 WlanSoftmacBridgeSetEthernetStatusResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        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) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x412503cb3aaa350b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for WlanSoftmacIfcBaseMarker {
    type Proxy = WlanSoftmacIfcBaseProxy;
    type RequestStream = WlanSoftmacIfcBaseRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = WlanSoftmacIfcBaseSynchronousProxy;

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

pub trait WlanSoftmacIfcBaseProxyInterface: Send + Sync {
    type ReportTxResultResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#report_tx_result(&self, tx_result: &WlanTxResult) -> Self::ReportTxResultResponseFut;
    type NotifyScanCompleteResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#notify_scan_complete(
        &self,
        payload: &WlanSoftmacIfcBaseNotifyScanCompleteRequest,
    ) -> Self::NotifyScanCompleteResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct WlanSoftmacIfcBaseSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for WlanSoftmacIfcBaseSynchronousProxy {
    type Proxy = WlanSoftmacIfcBaseProxy;
    type Protocol = WlanSoftmacIfcBaseMarker;

    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 WlanSoftmacIfcBaseSynchronousProxy {
    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<WlanSoftmacIfcBaseEvent, fidl::Error> {
        WlanSoftmacIfcBaseEvent::decode(
            self.client.wait_for_event::<WlanSoftmacIfcBaseMarker>(deadline)?,
        )
    }

    /// Reports the result of an attempted transmission.
    ///
    /// A device driver indicates support for `ReportTxResult()` using
    /// `fuchsia.wlan.common/DeviceExtension.report_tx_result_supported`.
    pub fn r#report_tx_result(
        &self,
        mut tx_result: &WlanTxResult,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacIfcBaseReportTxResultRequest,
            fidl::encoding::EmptyPayload,
            WlanSoftmacIfcBaseMarker,
        >(
            (tx_result,),
            0x5835c2f13d94e09a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Reports completion of a scan associated with the unique `scan_id`. `status`
    /// indicates whether the scan completed successfully, failed due to an error,
    /// or was cancelled.
    ///
    /// Return status indicates the reason for scan completion:
    ///   ZX_OK: All channels were scanned successfully.
    ///   ZX_ERR_CANCELLED: The scan was terminated by a user request, either an
    ///       explicit WlanSoftmac.CancelScan() or the initiation of an
    ///       incompatible request (e.g. connect).
    ///   ZX_ERR_OUT_OF_RANGE: The scan request included a prohibited channel.
    ///       This may be due to the current country setting.
    pub fn r#notify_scan_complete(
        &self,
        mut payload: &WlanSoftmacIfcBaseNotifyScanCompleteRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacIfcBaseNotifyScanCompleteRequest,
            fidl::encoding::EmptyPayload,
            WlanSoftmacIfcBaseMarker,
        >(
            payload,
            0x7045e3cd460dc42c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for WlanSoftmacIfcBaseProxy {
    type Protocol = WlanSoftmacIfcBaseMarker;

    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 WlanSoftmacIfcBaseProxy {
    /// Create a new Proxy for fuchsia.wlan.softmac/WlanSoftmacIfcBase.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <WlanSoftmacIfcBaseMarker 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) -> WlanSoftmacIfcBaseEventStream {
        WlanSoftmacIfcBaseEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Reports the result of an attempted transmission.
    ///
    /// A device driver indicates support for `ReportTxResult()` using
    /// `fuchsia.wlan.common/DeviceExtension.report_tx_result_supported`.
    pub fn r#report_tx_result(
        &self,
        mut tx_result: &WlanTxResult,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        WlanSoftmacIfcBaseProxyInterface::r#report_tx_result(self, tx_result)
    }

    /// Reports completion of a scan associated with the unique `scan_id`. `status`
    /// indicates whether the scan completed successfully, failed due to an error,
    /// or was cancelled.
    ///
    /// Return status indicates the reason for scan completion:
    ///   ZX_OK: All channels were scanned successfully.
    ///   ZX_ERR_CANCELLED: The scan was terminated by a user request, either an
    ///       explicit WlanSoftmac.CancelScan() or the initiation of an
    ///       incompatible request (e.g. connect).
    ///   ZX_ERR_OUT_OF_RANGE: The scan request included a prohibited channel.
    ///       This may be due to the current country setting.
    pub fn r#notify_scan_complete(
        &self,
        mut payload: &WlanSoftmacIfcBaseNotifyScanCompleteRequest,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        WlanSoftmacIfcBaseProxyInterface::r#notify_scan_complete(self, payload)
    }
}

impl WlanSoftmacIfcBaseProxyInterface for WlanSoftmacIfcBaseProxy {
    type ReportTxResultResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#report_tx_result(&self, mut tx_result: &WlanTxResult) -> Self::ReportTxResultResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5835c2f13d94e09a,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<WlanSoftmacIfcBaseReportTxResultRequest, ()>(
            (tx_result,),
            0x5835c2f13d94e09a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type NotifyScanCompleteResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#notify_scan_complete(
        &self,
        mut payload: &WlanSoftmacIfcBaseNotifyScanCompleteRequest,
    ) -> Self::NotifyScanCompleteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7045e3cd460dc42c,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<WlanSoftmacIfcBaseNotifyScanCompleteRequest, ()>(
            payload,
            0x7045e3cd460dc42c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for WlanSoftmacIfcBaseEventStream {
    type Item = Result<WlanSoftmacIfcBaseEvent, 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(WlanSoftmacIfcBaseEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum WlanSoftmacIfcBaseEvent {
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl WlanSoftmacIfcBaseEvent {
    /// Decodes a message buffer as a [`WlanSoftmacIfcBaseEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<WlanSoftmacIfcBaseEvent, 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 {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(WlanSoftmacIfcBaseEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <WlanSoftmacIfcBaseMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for WlanSoftmacIfcBaseRequestStream {
    type Protocol = WlanSoftmacIfcBaseMarker;
    type ControlHandle = WlanSoftmacIfcBaseControlHandle;

    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 {
        WlanSoftmacIfcBaseControlHandle { 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 WlanSoftmacIfcBaseRequestStream {
    type Item = Result<WlanSoftmacIfcBaseRequest, 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 WlanSoftmacIfcBaseRequestStream 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 {
                0x5835c2f13d94e09a => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(WlanSoftmacIfcBaseReportTxResultRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacIfcBaseReportTxResultRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = WlanSoftmacIfcBaseControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(WlanSoftmacIfcBaseRequest::ReportTxResult {tx_result: req.tx_result,

                        responder: WlanSoftmacIfcBaseReportTxResultResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x7045e3cd460dc42c => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(WlanSoftmacIfcBaseNotifyScanCompleteRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacIfcBaseNotifyScanCompleteRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = WlanSoftmacIfcBaseControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(WlanSoftmacIfcBaseRequest::NotifyScanComplete {payload: req,
                        responder: WlanSoftmacIfcBaseNotifyScanCompleteResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    Ok(WlanSoftmacIfcBaseRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: WlanSoftmacIfcBaseControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::OneWay,
                    })
                }
                _ if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    this.inner.send_framework_err(
                        fidl::encoding::FrameworkErr::UnknownMethod,
                        header.tx_id,
                        header.ordinal,
                        header.dynamic_flags(),
                        (bytes, handles),
                    )?;
                    Ok(WlanSoftmacIfcBaseRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: WlanSoftmacIfcBaseControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <WlanSoftmacIfcBaseMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Protocol containing methods common to both `WlanSoftmacIfc` and `WlanSoftmacIfcBridge`.
///
/// The `WlanSoftmacIfc` and `WlanSoftmacIfcBridge` protocols have common methods, as the latter
/// generally forwards `WlanSoftmacIfc` requests received in the wlansoftmac driver
/// to `WlanSoftmacIfcBridge` requests in the bridged driver. Composing this
/// protocol into `WlanSoftmacIfc` and `WlanSoftmacIfcBridge` minimizes the duplication of method
/// definitions (and associated request conversions that would be caused by such duplication).
///
/// **This protocol is not implemented directly by any component.** It is composed into `WlanSoftmacIfc`
/// and `WlanSoftmacIfcBridge`.
#[derive(Debug)]
pub enum WlanSoftmacIfcBaseRequest {
    /// Reports the result of an attempted transmission.
    ///
    /// A device driver indicates support for `ReportTxResult()` using
    /// `fuchsia.wlan.common/DeviceExtension.report_tx_result_supported`.
    ReportTxResult { tx_result: WlanTxResult, responder: WlanSoftmacIfcBaseReportTxResultResponder },
    /// Reports completion of a scan associated with the unique `scan_id`. `status`
    /// indicates whether the scan completed successfully, failed due to an error,
    /// or was cancelled.
    ///
    /// Return status indicates the reason for scan completion:
    ///   ZX_OK: All channels were scanned successfully.
    ///   ZX_ERR_CANCELLED: The scan was terminated by a user request, either an
    ///       explicit WlanSoftmac.CancelScan() or the initiation of an
    ///       incompatible request (e.g. connect).
    ///   ZX_ERR_OUT_OF_RANGE: The scan request included a prohibited channel.
    ///       This may be due to the current country setting.
    NotifyScanComplete {
        payload: WlanSoftmacIfcBaseNotifyScanCompleteRequest,
        responder: WlanSoftmacIfcBaseNotifyScanCompleteResponder,
    },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: WlanSoftmacIfcBaseControlHandle,
        method_type: fidl::MethodType,
    },
}

impl WlanSoftmacIfcBaseRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_report_tx_result(
        self,
    ) -> Option<(WlanTxResult, WlanSoftmacIfcBaseReportTxResultResponder)> {
        if let WlanSoftmacIfcBaseRequest::ReportTxResult { tx_result, responder } = self {
            Some((tx_result, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_scan_complete(
        self,
    ) -> Option<(
        WlanSoftmacIfcBaseNotifyScanCompleteRequest,
        WlanSoftmacIfcBaseNotifyScanCompleteResponder,
    )> {
        if let WlanSoftmacIfcBaseRequest::NotifyScanComplete { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            WlanSoftmacIfcBaseRequest::ReportTxResult { .. } => "report_tx_result",
            WlanSoftmacIfcBaseRequest::NotifyScanComplete { .. } => "notify_scan_complete",
            WlanSoftmacIfcBaseRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay,
                ..
            } => "unknown one-way method",
            WlanSoftmacIfcBaseRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay,
                ..
            } => "unknown two-way method",
        }
    }
}

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

impl WlanSoftmacIfcBaseControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 WlanSoftmacIfcBaseControlHandle {}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacIfcBaseControlHandle::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 WlanSoftmacIfcBaseReportTxResultResponder {
    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 WlanSoftmacIfcBaseReportTxResultResponder {
    type ControlHandle = WlanSoftmacIfcBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacIfcBaseControlHandle {
        &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 WlanSoftmacIfcBaseReportTxResultResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        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) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x5835c2f13d94e09a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacIfcBaseControlHandle::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 WlanSoftmacIfcBaseNotifyScanCompleteResponder {
    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 WlanSoftmacIfcBaseNotifyScanCompleteResponder {
    type ControlHandle = WlanSoftmacIfcBaseControlHandle;

    fn control_handle(&self) -> &WlanSoftmacIfcBaseControlHandle {
        &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 WlanSoftmacIfcBaseNotifyScanCompleteResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        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) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x7045e3cd460dc42c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for WlanSoftmacIfcBridgeMarker {
    type Proxy = WlanSoftmacIfcBridgeProxy;
    type RequestStream = WlanSoftmacIfcBridgeRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = WlanSoftmacIfcBridgeSynchronousProxy;

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

pub trait WlanSoftmacIfcBridgeProxyInterface: Send + Sync {
    type ReportTxResultResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#report_tx_result(&self, tx_result: &WlanTxResult) -> Self::ReportTxResultResponseFut;
    type NotifyScanCompleteResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#notify_scan_complete(
        &self,
        payload: &WlanSoftmacIfcBaseNotifyScanCompleteRequest,
    ) -> Self::NotifyScanCompleteResponseFut;
    type StopBridgedDriverResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#stop_bridged_driver(&self) -> Self::StopBridgedDriverResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct WlanSoftmacIfcBridgeSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for WlanSoftmacIfcBridgeSynchronousProxy {
    type Proxy = WlanSoftmacIfcBridgeProxy;
    type Protocol = WlanSoftmacIfcBridgeMarker;

    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 WlanSoftmacIfcBridgeSynchronousProxy {
    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<WlanSoftmacIfcBridgeEvent, fidl::Error> {
        WlanSoftmacIfcBridgeEvent::decode(
            self.client.wait_for_event::<WlanSoftmacIfcBridgeMarker>(deadline)?,
        )
    }

    /// Reports the result of an attempted transmission.
    ///
    /// A device driver indicates support for `ReportTxResult()` using
    /// `fuchsia.wlan.common/DeviceExtension.report_tx_result_supported`.
    pub fn r#report_tx_result(
        &self,
        mut tx_result: &WlanTxResult,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacIfcBaseReportTxResultRequest,
            fidl::encoding::EmptyPayload,
            WlanSoftmacIfcBridgeMarker,
        >(
            (tx_result,),
            0x5835c2f13d94e09a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Reports completion of a scan associated with the unique `scan_id`. `status`
    /// indicates whether the scan completed successfully, failed due to an error,
    /// or was cancelled.
    ///
    /// Return status indicates the reason for scan completion:
    ///   ZX_OK: All channels were scanned successfully.
    ///   ZX_ERR_CANCELLED: The scan was terminated by a user request, either an
    ///       explicit WlanSoftmac.CancelScan() or the initiation of an
    ///       incompatible request (e.g. connect).
    ///   ZX_ERR_OUT_OF_RANGE: The scan request included a prohibited channel.
    ///       This may be due to the current country setting.
    pub fn r#notify_scan_complete(
        &self,
        mut payload: &WlanSoftmacIfcBaseNotifyScanCompleteRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            WlanSoftmacIfcBaseNotifyScanCompleteRequest,
            fidl::encoding::EmptyPayload,
            WlanSoftmacIfcBridgeMarker,
        >(
            payload,
            0x7045e3cd460dc42c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Stop the bridged driver.
    ///
    /// Calling this method causes both the server end of this protocol (`WlanSoftmacIfcBridge`)
    /// to close and the client end of `WlanSoftmacBridge` to close. The server will not return a
    /// response from this method until after processing all queued events.
    ///
    /// In practice, the wlansoftmac driver calls this method during unbind.
    pub fn r#stop_bridged_driver(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::EmptyPayload,
            WlanSoftmacIfcBridgeMarker,
        >(
            (),
            0x112dbd0cc2251151,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for WlanSoftmacIfcBridgeProxy {
    type Protocol = WlanSoftmacIfcBridgeMarker;

    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 WlanSoftmacIfcBridgeProxy {
    /// Create a new Proxy for fuchsia.wlan.softmac/WlanSoftmacIfcBridge.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <WlanSoftmacIfcBridgeMarker 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) -> WlanSoftmacIfcBridgeEventStream {
        WlanSoftmacIfcBridgeEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Reports the result of an attempted transmission.
    ///
    /// A device driver indicates support for `ReportTxResult()` using
    /// `fuchsia.wlan.common/DeviceExtension.report_tx_result_supported`.
    pub fn r#report_tx_result(
        &self,
        mut tx_result: &WlanTxResult,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        WlanSoftmacIfcBridgeProxyInterface::r#report_tx_result(self, tx_result)
    }

    /// Reports completion of a scan associated with the unique `scan_id`. `status`
    /// indicates whether the scan completed successfully, failed due to an error,
    /// or was cancelled.
    ///
    /// Return status indicates the reason for scan completion:
    ///   ZX_OK: All channels were scanned successfully.
    ///   ZX_ERR_CANCELLED: The scan was terminated by a user request, either an
    ///       explicit WlanSoftmac.CancelScan() or the initiation of an
    ///       incompatible request (e.g. connect).
    ///   ZX_ERR_OUT_OF_RANGE: The scan request included a prohibited channel.
    ///       This may be due to the current country setting.
    pub fn r#notify_scan_complete(
        &self,
        mut payload: &WlanSoftmacIfcBaseNotifyScanCompleteRequest,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        WlanSoftmacIfcBridgeProxyInterface::r#notify_scan_complete(self, payload)
    }

    /// Stop the bridged driver.
    ///
    /// Calling this method causes both the server end of this protocol (`WlanSoftmacIfcBridge`)
    /// to close and the client end of `WlanSoftmacBridge` to close. The server will not return a
    /// response from this method until after processing all queued events.
    ///
    /// In practice, the wlansoftmac driver calls this method during unbind.
    pub fn r#stop_bridged_driver(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        WlanSoftmacIfcBridgeProxyInterface::r#stop_bridged_driver(self)
    }
}

impl WlanSoftmacIfcBridgeProxyInterface for WlanSoftmacIfcBridgeProxy {
    type ReportTxResultResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#report_tx_result(&self, mut tx_result: &WlanTxResult) -> Self::ReportTxResultResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5835c2f13d94e09a,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<WlanSoftmacIfcBaseReportTxResultRequest, ()>(
            (tx_result,),
            0x5835c2f13d94e09a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type NotifyScanCompleteResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#notify_scan_complete(
        &self,
        mut payload: &WlanSoftmacIfcBaseNotifyScanCompleteRequest,
    ) -> Self::NotifyScanCompleteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7045e3cd460dc42c,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<WlanSoftmacIfcBaseNotifyScanCompleteRequest, ()>(
            payload,
            0x7045e3cd460dc42c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

impl futures::Stream for WlanSoftmacIfcBridgeEventStream {
    type Item = Result<WlanSoftmacIfcBridgeEvent, 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(WlanSoftmacIfcBridgeEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum WlanSoftmacIfcBridgeEvent {
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl WlanSoftmacIfcBridgeEvent {
    /// Decodes a message buffer as a [`WlanSoftmacIfcBridgeEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<WlanSoftmacIfcBridgeEvent, 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 {
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(WlanSoftmacIfcBridgeEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <WlanSoftmacIfcBridgeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for WlanSoftmacIfcBridgeRequestStream {
    type Protocol = WlanSoftmacIfcBridgeMarker;
    type ControlHandle = WlanSoftmacIfcBridgeControlHandle;

    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 {
        WlanSoftmacIfcBridgeControlHandle { 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 WlanSoftmacIfcBridgeRequestStream {
    type Item = Result<WlanSoftmacIfcBridgeRequest, 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 WlanSoftmacIfcBridgeRequestStream 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 {
                0x5835c2f13d94e09a => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(WlanSoftmacIfcBaseReportTxResultRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacIfcBaseReportTxResultRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = WlanSoftmacIfcBridgeControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(WlanSoftmacIfcBridgeRequest::ReportTxResult {tx_result: req.tx_result,

                        responder: WlanSoftmacIfcBridgeReportTxResultResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x7045e3cd460dc42c => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(WlanSoftmacIfcBaseNotifyScanCompleteRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanSoftmacIfcBaseNotifyScanCompleteRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = WlanSoftmacIfcBridgeControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(WlanSoftmacIfcBridgeRequest::NotifyScanComplete {payload: req,
                        responder: WlanSoftmacIfcBridgeNotifyScanCompleteResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x112dbd0cc2251151 => {
                    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 = WlanSoftmacIfcBridgeControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(WlanSoftmacIfcBridgeRequest::StopBridgedDriver {
                        responder: WlanSoftmacIfcBridgeStopBridgedDriverResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    Ok(WlanSoftmacIfcBridgeRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: WlanSoftmacIfcBridgeControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::OneWay,
                    })
                }
                _ if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    this.inner.send_framework_err(
                        fidl::encoding::FrameworkErr::UnknownMethod,
                        header.tx_id,
                        header.ordinal,
                        header.dynamic_flags(),
                        (bytes, handles),
                    )?;
                    Ok(WlanSoftmacIfcBridgeRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: WlanSoftmacIfcBridgeControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <WlanSoftmacIfcBridgeMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Protocol that transports `WlanSoftmacIfc` requests from the wlansoftmac driver to
/// the bridged driver.
///
/// This protocol should always be available at HEAD since it's intended to be an in-tree only protocol.
/// This protocol only exists because wlansoftmac cannot be implemented in Rust and must interact with
/// the wlansoftmac-c, wlansoftmac-rust, and wlan-mlme Rust crates.
#[derive(Debug)]
pub enum WlanSoftmacIfcBridgeRequest {
    /// Reports the result of an attempted transmission.
    ///
    /// A device driver indicates support for `ReportTxResult()` using
    /// `fuchsia.wlan.common/DeviceExtension.report_tx_result_supported`.
    ReportTxResult {
        tx_result: WlanTxResult,
        responder: WlanSoftmacIfcBridgeReportTxResultResponder,
    },
    /// Reports completion of a scan associated with the unique `scan_id`. `status`
    /// indicates whether the scan completed successfully, failed due to an error,
    /// or was cancelled.
    ///
    /// Return status indicates the reason for scan completion:
    ///   ZX_OK: All channels were scanned successfully.
    ///   ZX_ERR_CANCELLED: The scan was terminated by a user request, either an
    ///       explicit WlanSoftmac.CancelScan() or the initiation of an
    ///       incompatible request (e.g. connect).
    ///   ZX_ERR_OUT_OF_RANGE: The scan request included a prohibited channel.
    ///       This may be due to the current country setting.
    NotifyScanComplete {
        payload: WlanSoftmacIfcBaseNotifyScanCompleteRequest,
        responder: WlanSoftmacIfcBridgeNotifyScanCompleteResponder,
    },
    /// Stop the bridged driver.
    ///
    /// Calling this method causes both the server end of this protocol (`WlanSoftmacIfcBridge`)
    /// to close and the client end of `WlanSoftmacBridge` to close. The server will not return a
    /// response from this method until after processing all queued events.
    ///
    /// In practice, the wlansoftmac driver calls this method during unbind.
    StopBridgedDriver { responder: WlanSoftmacIfcBridgeStopBridgedDriverResponder },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: WlanSoftmacIfcBridgeControlHandle,
        method_type: fidl::MethodType,
    },
}

impl WlanSoftmacIfcBridgeRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_report_tx_result(
        self,
    ) -> Option<(WlanTxResult, WlanSoftmacIfcBridgeReportTxResultResponder)> {
        if let WlanSoftmacIfcBridgeRequest::ReportTxResult { tx_result, responder } = self {
            Some((tx_result, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_notify_scan_complete(
        self,
    ) -> Option<(
        WlanSoftmacIfcBaseNotifyScanCompleteRequest,
        WlanSoftmacIfcBridgeNotifyScanCompleteResponder,
    )> {
        if let WlanSoftmacIfcBridgeRequest::NotifyScanComplete { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_bridged_driver(
        self,
    ) -> Option<(WlanSoftmacIfcBridgeStopBridgedDriverResponder)> {
        if let WlanSoftmacIfcBridgeRequest::StopBridgedDriver { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            WlanSoftmacIfcBridgeRequest::ReportTxResult { .. } => "report_tx_result",
            WlanSoftmacIfcBridgeRequest::NotifyScanComplete { .. } => "notify_scan_complete",
            WlanSoftmacIfcBridgeRequest::StopBridgedDriver { .. } => "stop_bridged_driver",
            WlanSoftmacIfcBridgeRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay,
                ..
            } => "unknown one-way method",
            WlanSoftmacIfcBridgeRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay,
                ..
            } => "unknown two-way method",
        }
    }
}

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

impl WlanSoftmacIfcBridgeControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 WlanSoftmacIfcBridgeControlHandle {}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacIfcBridgeControlHandle::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 WlanSoftmacIfcBridgeReportTxResultResponder {
    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 WlanSoftmacIfcBridgeReportTxResultResponder {
    type ControlHandle = WlanSoftmacIfcBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacIfcBridgeControlHandle {
        &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 WlanSoftmacIfcBridgeReportTxResultResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        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) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x5835c2f13d94e09a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacIfcBridgeControlHandle::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 WlanSoftmacIfcBridgeNotifyScanCompleteResponder {
    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 WlanSoftmacIfcBridgeNotifyScanCompleteResponder {
    type ControlHandle = WlanSoftmacIfcBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacIfcBridgeControlHandle {
        &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 WlanSoftmacIfcBridgeNotifyScanCompleteResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        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) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x7045e3cd460dc42c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`WlanSoftmacIfcBridgeControlHandle::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 WlanSoftmacIfcBridgeStopBridgedDriverResponder {
    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 WlanSoftmacIfcBridgeStopBridgedDriverResponder {
    type ControlHandle = WlanSoftmacIfcBridgeControlHandle;

    fn control_handle(&self) -> &WlanSoftmacIfcBridgeControlHandle {
        &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 WlanSoftmacIfcBridgeStopBridgedDriverResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        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) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x112dbd0cc2251151,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for WlanTxMarker {
    type Proxy = WlanTxProxy;
    type RequestStream = WlanTxRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = WlanTxSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) WlanTx";
}
pub type WlanTxTransferResult = Result<(), i32>;

pub trait WlanTxProxyInterface: Send + Sync {
    type TransferResponseFut: std::future::Future<Output = Result<WlanTxTransferResult, fidl::Error>>
        + Send;
    fn r#transfer(&self, payload: &WlanTxTransferRequest) -> Self::TransferResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct WlanTxSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for WlanTxSynchronousProxy {
    type Proxy = WlanTxProxy;
    type Protocol = WlanTxMarker;

    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 WlanTxSynchronousProxy {
    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<WlanTxEvent, fidl::Error> {
        WlanTxEvent::decode(self.client.wait_for_event::<WlanTxMarker>(deadline)?)
    }

    pub fn r#transfer(
        &self,
        mut payload: &WlanTxTransferRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WlanTxTransferResult, fidl::Error> {
        let _response = self.client.send_query::<
            WlanTxTransferRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            WlanTxMarker,
        >(
            payload,
            0x19f8ff7a8b910ab3,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for WlanTxProxy {
    type Protocol = WlanTxMarker;

    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 WlanTxProxy {
    /// Create a new Proxy for fuchsia.wlan.softmac/WlanTx.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <WlanTxMarker 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) -> WlanTxEventStream {
        WlanTxEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#transfer(
        &self,
        mut payload: &WlanTxTransferRequest,
    ) -> fidl::client::QueryResponseFut<
        WlanTxTransferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WlanTxProxyInterface::r#transfer(self, payload)
    }
}

impl WlanTxProxyInterface for WlanTxProxy {
    type TransferResponseFut = fidl::client::QueryResponseFut<
        WlanTxTransferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#transfer(&self, mut payload: &WlanTxTransferRequest) -> Self::TransferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WlanTxTransferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x19f8ff7a8b910ab3,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<WlanTxTransferRequest, WlanTxTransferResult>(
            payload,
            0x19f8ff7a8b910ab3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

impl futures::Stream for WlanTxEventStream {
    type Item = Result<WlanTxEvent, 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(WlanTxEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

impl WlanTxEvent {
    /// Decodes a message buffer as a [`WlanTxEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<WlanTxEvent, 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: <WlanTxMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for WlanTxRequestStream {
    type Protocol = WlanTxMarker;
    type ControlHandle = WlanTxControlHandle;

    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 {
        WlanTxControlHandle { 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 WlanTxRequestStream {
    type Item = Result<WlanTxRequest, 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 WlanTxRequestStream 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 {
                    0x19f8ff7a8b910ab3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            WlanTxTransferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanTxTransferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = WlanTxControlHandle { inner: this.inner.clone() };
                        Ok(WlanTxRequest::Transfer {
                            payload: req,
                            responder: WlanTxTransferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <WlanTxMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol for sending a WLAN frame from the bridged wlansoftmac
/// driver to the wlansoftmac driver.
///
/// # Experimental
///
/// This protocol is implemented as a foreign function interface (FFI)
/// between the wlansoftmac driver and the bridged driver solely to improve
/// the performance of processing data frames through the wlan-mlme library.
#[derive(Debug)]
pub enum WlanTxRequest {
    Transfer { payload: WlanTxTransferRequest, responder: WlanTxTransferResponder },
}

impl WlanTxRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_transfer(self) -> Option<(WlanTxTransferRequest, WlanTxTransferResponder)> {
        if let WlanTxRequest::Transfer { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

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

impl WlanTxControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        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 WlanTxControlHandle {}

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

/// Set the the channel to be shutdown (see [`WlanTxControlHandle::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 WlanTxTransferResponder {
    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 WlanTxTransferResponder {
    type ControlHandle = WlanTxControlHandle;

    fn control_handle(&self) -> &WlanTxControlHandle {
        &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 WlanTxTransferResponder {
    /// 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,
                0x19f8ff7a8b910ab3,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for WlanSoftmacBridgeStartRequest {
        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 WlanSoftmacBridgeStartRequest {
        type Owned = Self;

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

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

    unsafe impl
        fidl::encoding::Encode<
            WlanSoftmacBridgeStartRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut WlanSoftmacBridgeStartRequest
    {
        #[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::<WlanSoftmacBridgeStartRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                WlanSoftmacBridgeStartRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<WlanSoftmacIfcBridgeMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.ifc_bridge
                    ),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.ethernet_tx),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.wlan_rx),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<WlanSoftmacIfcBridgeMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<
            WlanSoftmacBridgeStartRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[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::<WlanSoftmacBridgeStartRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for WlanSoftmacBridgeStartRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                ifc_bridge: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<WlanSoftmacIfcBridgeMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                ethernet_tx: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                wlan_rx: fidl::new_empty!(u64, 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.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<WlanSoftmacIfcBridgeMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.ifc_bridge,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.ethernet_tx,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.wlan_rx,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for WlanSoftmacBridgeStartResponse {
        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 WlanSoftmacBridgeStartResponse {
        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<
            WlanSoftmacBridgeStartResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut WlanSoftmacBridgeStartResponse
    {
        #[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::<WlanSoftmacBridgeStartResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                WlanSoftmacBridgeStartResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.sme_channel
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            WlanSoftmacBridgeStartResponse,
            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::<WlanSoftmacBridgeStartResponse>(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 WlanSoftmacBridgeStartResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                sme_channel: fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, 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::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.sme_channel, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }
}