fidl_fuchsia_wlan_device_service/

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceMonitorGetApSmeRequest {
    pub iface_id: u16,
    pub sme_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ApSmeMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceMonitorGetClientSmeRequest {
    pub iface_id: u16,
    pub sme_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ClientSmeMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceMonitorGetSmeTelemetryRequest {
    pub iface_id: u16,
    pub telemetry_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::TelemetryMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceMonitorWatchDevicesRequest {
    pub watcher: fidl::endpoints::ServerEnd<DeviceWatcherMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceMonitorWatchPhyEventsRequest {
    pub watcher: fidl::endpoints::ServerEnd<PhyEventWatcherMarker>,
}

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

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

impl fidl::endpoints::ProtocolMarker for DeviceMonitorMarker {
    type Proxy = DeviceMonitorProxy;
    type RequestStream = DeviceMonitorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DeviceMonitorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.wlan.device.service.DeviceMonitor";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DeviceMonitorMarker {}
pub type DeviceMonitorGetSupportedMacRolesResult =
    Result<Vec<fidl_fuchsia_wlan_common::WlanMacRole>, i32>;
pub type DeviceMonitorGetCountryResult = Result<GetCountryResponse, i32>;
pub type DeviceMonitorGetPowerSaveModeResult = Result<GetPowerSaveModeResponse, i32>;
pub type DeviceMonitorPowerDownResult = Result<(), i32>;
pub type DeviceMonitorPowerUpResult = Result<(), i32>;
pub type DeviceMonitorResetResult = Result<(), i32>;
pub type DeviceMonitorSetTxPowerScenarioResult = Result<(), i32>;
pub type DeviceMonitorResetTxPowerScenarioResult = Result<(), i32>;
pub type DeviceMonitorGetTxPowerScenarioResult =
    Result<fidl_fuchsia_wlan_internal::TxPowerScenario, i32>;
pub type DeviceMonitorGetPowerStateResult = Result<bool, i32>;
pub type DeviceMonitorSetBtCoexistenceModeResult = Result<(), i32>;
pub type DeviceMonitorCreateIfaceResult =
    Result<DeviceMonitorCreateIfaceResponse, DeviceMonitorError>;
pub type DeviceMonitorQueryIfaceResult = Result<QueryIfaceResponse, i32>;
pub type DeviceMonitorQueryIfaceCapabilitiesResult =
    Result<fidl_fuchsia_wlan_common::ApfPacketFilterSupport, i32>;
pub type DeviceMonitorGetClientSmeResult = Result<(), i32>;
pub type DeviceMonitorGetApSmeResult = Result<(), i32>;
pub type DeviceMonitorGetSmeTelemetryResult = Result<(), i32>;

pub trait DeviceMonitorProxyInterface: Send + Sync {
    type ListPhysResponseFut: std::future::Future<Output = Result<Vec<u16>, fidl::Error>> + Send;
    fn r#list_phys(&self) -> Self::ListPhysResponseFut;
    type ListIfacesResponseFut: std::future::Future<Output = Result<Vec<u16>, fidl::Error>> + Send;
    fn r#list_ifaces(&self) -> Self::ListIfacesResponseFut;
    type GetSupportedMacRolesResponseFut: std::future::Future<Output = Result<DeviceMonitorGetSupportedMacRolesResult, fidl::Error>>
        + Send;
    fn r#get_supported_mac_roles(&self, phy_id: u16) -> Self::GetSupportedMacRolesResponseFut;
    fn r#watch_devices(
        &self,
        watcher: fidl::endpoints::ServerEnd<DeviceWatcherMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#watch_phy_events(
        &self,
        watcher: fidl::endpoints::ServerEnd<PhyEventWatcherMarker>,
    ) -> Result<(), fidl::Error>;
    type GetCountryResponseFut: std::future::Future<Output = Result<DeviceMonitorGetCountryResult, fidl::Error>>
        + Send;
    fn r#get_country(&self, phy_id: u16) -> Self::GetCountryResponseFut;
    type SetCountryResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#set_country(&self, req: &SetCountryRequest) -> Self::SetCountryResponseFut;
    type ClearCountryResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#clear_country(&self, req: &ClearCountryRequest) -> Self::ClearCountryResponseFut;
    type SetPowerSaveModeResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#set_power_save_mode(
        &self,
        req: &SetPowerSaveModeRequest,
    ) -> Self::SetPowerSaveModeResponseFut;
    type GetPowerSaveModeResponseFut: std::future::Future<Output = Result<DeviceMonitorGetPowerSaveModeResult, fidl::Error>>
        + Send;
    fn r#get_power_save_mode(&self, phy_id: u16) -> Self::GetPowerSaveModeResponseFut;
    type PowerDownResponseFut: std::future::Future<Output = Result<DeviceMonitorPowerDownResult, fidl::Error>>
        + Send;
    fn r#power_down(&self, phy_id: u16) -> Self::PowerDownResponseFut;
    type PowerUpResponseFut: std::future::Future<Output = Result<DeviceMonitorPowerUpResult, fidl::Error>>
        + Send;
    fn r#power_up(&self, phy_id: u16) -> Self::PowerUpResponseFut;
    type ResetResponseFut: std::future::Future<Output = Result<DeviceMonitorResetResult, fidl::Error>>
        + Send;
    fn r#reset(&self, phy_id: u16) -> Self::ResetResponseFut;
    type SetTxPowerScenarioResponseFut: std::future::Future<Output = Result<DeviceMonitorSetTxPowerScenarioResult, fidl::Error>>
        + Send;
    fn r#set_tx_power_scenario(
        &self,
        phy_id: u16,
        scenario: fidl_fuchsia_wlan_internal::TxPowerScenario,
    ) -> Self::SetTxPowerScenarioResponseFut;
    type ResetTxPowerScenarioResponseFut: std::future::Future<Output = Result<DeviceMonitorResetTxPowerScenarioResult, fidl::Error>>
        + Send;
    fn r#reset_tx_power_scenario(&self, phy_id: u16) -> Self::ResetTxPowerScenarioResponseFut;
    type GetTxPowerScenarioResponseFut: std::future::Future<Output = Result<DeviceMonitorGetTxPowerScenarioResult, fidl::Error>>
        + Send;
    fn r#get_tx_power_scenario(&self, phy_id: u16) -> Self::GetTxPowerScenarioResponseFut;
    type GetPowerStateResponseFut: std::future::Future<Output = Result<DeviceMonitorGetPowerStateResult, fidl::Error>>
        + Send;
    fn r#get_power_state(&self, phy_id: u16) -> Self::GetPowerStateResponseFut;
    type SetBtCoexistenceModeResponseFut: std::future::Future<Output = Result<DeviceMonitorSetBtCoexistenceModeResult, fidl::Error>>
        + Send;
    fn r#set_bt_coexistence_mode(
        &self,
        phy_id: u16,
        mode: fidl_fuchsia_wlan_internal::BtCoexistenceMode,
    ) -> Self::SetBtCoexistenceModeResponseFut;
    type CreateIfaceResponseFut: std::future::Future<Output = Result<DeviceMonitorCreateIfaceResult, fidl::Error>>
        + Send;
    fn r#create_iface(
        &self,
        payload: &DeviceMonitorCreateIfaceRequest,
    ) -> Self::CreateIfaceResponseFut;
    type QueryIfaceResponseFut: std::future::Future<Output = Result<DeviceMonitorQueryIfaceResult, fidl::Error>>
        + Send;
    fn r#query_iface(&self, iface_id: u16) -> Self::QueryIfaceResponseFut;
    type DestroyIfaceResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#destroy_iface(&self, req: &DestroyIfaceRequest) -> Self::DestroyIfaceResponseFut;
    type QueryIfaceCapabilitiesResponseFut: std::future::Future<Output = Result<DeviceMonitorQueryIfaceCapabilitiesResult, fidl::Error>>
        + Send;
    fn r#query_iface_capabilities(&self, iface_id: u16) -> Self::QueryIfaceCapabilitiesResponseFut;
    type GetClientSmeResponseFut: std::future::Future<Output = Result<DeviceMonitorGetClientSmeResult, fidl::Error>>
        + Send;
    fn r#get_client_sme(
        &self,
        iface_id: u16,
        sme_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ClientSmeMarker>,
    ) -> Self::GetClientSmeResponseFut;
    type GetApSmeResponseFut: std::future::Future<Output = Result<DeviceMonitorGetApSmeResult, fidl::Error>>
        + Send;
    fn r#get_ap_sme(
        &self,
        iface_id: u16,
        sme_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ApSmeMarker>,
    ) -> Self::GetApSmeResponseFut;
    type GetSmeTelemetryResponseFut: std::future::Future<Output = Result<DeviceMonitorGetSmeTelemetryResult, fidl::Error>>
        + Send;
    fn r#get_sme_telemetry(
        &self,
        iface_id: u16,
        telemetry_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::TelemetryMarker>,
    ) -> Self::GetSmeTelemetryResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DeviceMonitorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DeviceMonitorSynchronousProxy {
    type Proxy = DeviceMonitorProxy;
    type Protocol = DeviceMonitorMarker;

    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 DeviceMonitorSynchronousProxy {
    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<DeviceMonitorEvent, fidl::Error> {
        DeviceMonitorEvent::decode(self.client.wait_for_event::<DeviceMonitorMarker>(deadline)?)
    }

    pub fn r#list_phys(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u16>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            DeviceMonitorListPhysResponse,
            DeviceMonitorMarker,
        >(
            (),
            0x3a08518874196aab,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.phy_list)
    }

    pub fn r#list_ifaces(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<u16>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            DeviceMonitorListIfacesResponse,
            DeviceMonitorMarker,
        >(
            (),
            0x129e758fb8e0b113,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.iface_list)
    }

    pub fn r#get_supported_mac_roles(
        &self,
        mut phy_id: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorGetSupportedMacRolesResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorGetSupportedMacRolesRequest,
            fidl::encoding::ResultType<DeviceMonitorGetSupportedMacRolesResponse, i32>,
            DeviceMonitorMarker,
        >(
            (phy_id,),
            0x172b3d2eabd5a14e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.supported_mac_roles))
    }

    pub fn r#watch_devices(
        &self,
        mut watcher: fidl::endpoints::ServerEnd<DeviceWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceMonitorWatchDevicesRequest>(
            (watcher,),
            0x4615941e67e31b8e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#watch_phy_events(
        &self,
        mut watcher: fidl::endpoints::ServerEnd<PhyEventWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceMonitorWatchPhyEventsRequest>(
            (watcher,),
            0x2c5af9d064099745,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#get_country(
        &self,
        mut phy_id: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorGetCountryResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorGetCountryRequest,
            fidl::encoding::ResultType<DeviceMonitorGetCountryResponse, i32>,
            DeviceMonitorMarker,
        >(
            (phy_id,),
            0x6f1040bd81bde90e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.resp))
    }

    pub fn r#set_country(
        &self,
        mut req: &SetCountryRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorSetCountryRequest,
            DeviceMonitorSetCountryResponse,
            DeviceMonitorMarker,
        >(
            (req,),
            0xdaa7b77a5a6e71b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    pub fn r#clear_country(
        &self,
        mut req: &ClearCountryRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorClearCountryRequest,
            DeviceMonitorClearCountryResponse,
            DeviceMonitorMarker,
        >(
            (req,),
            0x66714d61103120e9,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    pub fn r#set_power_save_mode(
        &self,
        mut req: &SetPowerSaveModeRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorSetPowerSaveModeRequest,
            DeviceMonitorSetPowerSaveModeResponse,
            DeviceMonitorMarker,
        >(
            (req,),
            0x62202b4d360533bc,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    pub fn r#get_power_save_mode(
        &self,
        mut phy_id: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorGetPowerSaveModeResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorGetPowerSaveModeRequest,
            fidl::encoding::ResultType<DeviceMonitorGetPowerSaveModeResponse, i32>,
            DeviceMonitorMarker,
        >(
            (phy_id,),
            0x14304d406ada8693,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.resp))
    }

    /// All interfaces should be deleted before calling this method. If supported, the
    /// wlan driver will power down the wlan chip. Refer to wlan.phyimpl fidl for more details.
    pub fn r#power_down(
        &self,
        mut phy_id: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorPowerDownResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorPowerDownRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMonitorMarker,
        >(
            (phy_id,),
            0x374ad717fe8902e0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// If supported, the wlan driver will power up the wlan chip. Refer to wlan.phyimpl fidl
    /// for more details.
    pub fn r#power_up(
        &self,
        mut phy_id: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorPowerUpResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorPowerUpRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMonitorMarker,
        >(
            (phy_id,),
            0xa2379b639869c17,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// If supported, the wlan driver will reset the wlan chip. An attempt is made to delete
    /// any existing interfaces. Refer to wlan.phyimpl fidl for more details.
    pub fn r#reset(
        &self,
        mut phy_id: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorResetResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorResetRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMonitorMarker,
        >(
            (phy_id,),
            0x6def240c9f8c6867,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Applies the provided TxPowerScenario to the specified PHY.
    pub fn r#set_tx_power_scenario(
        &self,
        mut phy_id: u16,
        mut scenario: fidl_fuchsia_wlan_internal::TxPowerScenario,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorSetTxPowerScenarioResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorSetTxPowerScenarioRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMonitorMarker,
        >(
            (phy_id, scenario,),
            0x7c51443a985934fd,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Clears any existing TxPowerScenario that has been applied and resets the PHY to use its default TxPowerScenario.
    pub fn r#reset_tx_power_scenario(
        &self,
        mut phy_id: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorResetTxPowerScenarioResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorResetTxPowerScenarioRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMonitorMarker,
        >(
            (phy_id,),
            0x4790357c9cdddc4a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Queries the current TxPowerScenario setting for the specified PHY.
    pub fn r#get_tx_power_scenario(
        &self,
        mut phy_id: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorGetTxPowerScenarioResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorGetTxPowerScenarioRequest,
            fidl::encoding::ResultType<DeviceMonitorGetTxPowerScenarioResponse, i32>,
            DeviceMonitorMarker,
        >(
            (phy_id,),
            0x555fb197f90e9830,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.scenario))
    }

    /// This will return the current power state of the wlan chip.
    pub fn r#get_power_state(
        &self,
        mut phy_id: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorGetPowerStateResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorGetPowerStateRequest,
            fidl::encoding::ResultType<DeviceMonitorGetPowerStateResponse, i32>,
            DeviceMonitorMarker,
        >(
            (phy_id,),
            0x58cf95c5bbbe3f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.power_on))
    }

    /// Set the Bluetooth coexistence mode.
    /// Likely errors include:
    ///     * NOT_FOUND: The given phy_id does not exist.
    ///     * NOT_SUPPORTED: The specified BT coexistence mode is not supported.
    pub fn r#set_bt_coexistence_mode(
        &self,
        mut phy_id: u16,
        mut mode: fidl_fuchsia_wlan_internal::BtCoexistenceMode,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorSetBtCoexistenceModeResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorSetBtCoexistenceModeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMonitorMarker,
        >(
            (phy_id, mode,),
            0x97539596c9a79c7,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#create_iface(
        &self,
        mut payload: &DeviceMonitorCreateIfaceRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorCreateIfaceResult, fidl::Error> {
        let _response =
            self.client.send_query::<DeviceMonitorCreateIfaceRequest, fidl::encoding::ResultType<
                DeviceMonitorCreateIfaceResponse,
                DeviceMonitorError,
            >, DeviceMonitorMarker>(
                payload,
                0x1e1d30c24c0ec144,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#query_iface(
        &self,
        mut iface_id: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorQueryIfaceResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorQueryIfaceRequest,
            fidl::encoding::ResultType<DeviceMonitorQueryIfaceResponse, i32>,
            DeviceMonitorMarker,
        >(
            (iface_id,),
            0x1a48c4a2b86259ef,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.resp))
    }

    pub fn r#destroy_iface(
        &self,
        mut req: &DestroyIfaceRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorDestroyIfaceRequest,
            DeviceMonitorDestroyIfaceResponse,
            DeviceMonitorMarker,
        >(
            (req,),
            0x4c77982c1616a3b0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    pub fn r#query_iface_capabilities(
        &self,
        mut iface_id: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorQueryIfaceCapabilitiesResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorQueryIfaceCapabilitiesRequest,
            fidl::encoding::ResultType<DeviceMonitorQueryIfaceCapabilitiesResponse, i32>,
            DeviceMonitorMarker,
        >(
            (iface_id,),
            0x37e8b884766de0f8,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.apf_support))
    }

    /// Attempt to establish a new connection to a Client SME.
    /// Connections may be established for the whole lifetime of the SME,
    /// but concurrent connections might lead to unexpected behavior.
    /// Likely errors include:
    ///     * NOT_FOUND: The given iface_id does not exist.
    ///     * NOT_SUPPORTED: The underlying SME is not a Client SME.
    ///     * PEER_CLOSED: The underlying SME is shutting down.
    pub fn r#get_client_sme(
        &self,
        mut iface_id: u16,
        mut sme_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ClientSmeMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorGetClientSmeResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorGetClientSmeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMonitorMarker,
        >(
            (iface_id, sme_server,),
            0x1b056c379ca98273,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Attempt to establish a new connection to an AP SME.
    /// Connections may be established for the whole lifetime of the SME,
    /// but concurrent connections might lead to unexpected behavior.
    /// Likely errors include:
    ///     * NOT_FOUND: The given iface_id does not exist.
    ///     * NOT_SUPPORTED: The underlying SME is not a Client SME.
    ///     * PEER_CLOSED: The underlying SME is shutting down.
    pub fn r#get_ap_sme(
        &self,
        mut iface_id: u16,
        mut sme_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ApSmeMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorGetApSmeResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorGetApSmeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMonitorMarker,
        >(
            (iface_id, sme_server,),
            0x754de680c4318c52,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Attempt to establish a new connection to telemetry for an SME.
    /// Connections may be established for the whole lifetime of the SME, and
    /// concurrent connections are safe since this is a read-only API.
    /// Likely errors include:
    ///     * NOT_FOUND: The given iface_id does not exist.
    ///     * NOT_SUPPORTED: The underlying SME is not a Client SME.
    ///     * PEER_CLOSED: The underlying SME is shutting down.
    pub fn r#get_sme_telemetry(
        &self,
        mut iface_id: u16,
        mut telemetry_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::TelemetryMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceMonitorGetSmeTelemetryResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceMonitorGetSmeTelemetryRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMonitorMarker,
        >(
            (iface_id, telemetry_server,),
            0x1baf42b003f7452a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DeviceMonitorProxy {
    type Protocol = DeviceMonitorMarker;

    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 DeviceMonitorProxy {
    /// Create a new Proxy for fuchsia.wlan.device.service/DeviceMonitor.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DeviceMonitorMarker 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) -> DeviceMonitorEventStream {
        DeviceMonitorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#list_phys(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<u16>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        DeviceMonitorProxyInterface::r#list_phys(self)
    }

    pub fn r#list_ifaces(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<u16>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        DeviceMonitorProxyInterface::r#list_ifaces(self)
    }

    pub fn r#get_supported_mac_roles(
        &self,
        mut phy_id: u16,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorGetSupportedMacRolesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#get_supported_mac_roles(self, phy_id)
    }

    pub fn r#watch_devices(
        &self,
        mut watcher: fidl::endpoints::ServerEnd<DeviceWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceMonitorProxyInterface::r#watch_devices(self, watcher)
    }

    pub fn r#watch_phy_events(
        &self,
        mut watcher: fidl::endpoints::ServerEnd<PhyEventWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceMonitorProxyInterface::r#watch_phy_events(self, watcher)
    }

    pub fn r#get_country(
        &self,
        mut phy_id: u16,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorGetCountryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#get_country(self, phy_id)
    }

    pub fn r#set_country(
        &self,
        mut req: &SetCountryRequest,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DeviceMonitorProxyInterface::r#set_country(self, req)
    }

    pub fn r#clear_country(
        &self,
        mut req: &ClearCountryRequest,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DeviceMonitorProxyInterface::r#clear_country(self, req)
    }

    pub fn r#set_power_save_mode(
        &self,
        mut req: &SetPowerSaveModeRequest,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DeviceMonitorProxyInterface::r#set_power_save_mode(self, req)
    }

    pub fn r#get_power_save_mode(
        &self,
        mut phy_id: u16,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorGetPowerSaveModeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#get_power_save_mode(self, phy_id)
    }

    /// All interfaces should be deleted before calling this method. If supported, the
    /// wlan driver will power down the wlan chip. Refer to wlan.phyimpl fidl for more details.
    pub fn r#power_down(
        &self,
        mut phy_id: u16,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorPowerDownResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#power_down(self, phy_id)
    }

    /// If supported, the wlan driver will power up the wlan chip. Refer to wlan.phyimpl fidl
    /// for more details.
    pub fn r#power_up(
        &self,
        mut phy_id: u16,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorPowerUpResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#power_up(self, phy_id)
    }

    /// If supported, the wlan driver will reset the wlan chip. An attempt is made to delete
    /// any existing interfaces. Refer to wlan.phyimpl fidl for more details.
    pub fn r#reset(
        &self,
        mut phy_id: u16,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorResetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#reset(self, phy_id)
    }

    /// Applies the provided TxPowerScenario to the specified PHY.
    pub fn r#set_tx_power_scenario(
        &self,
        mut phy_id: u16,
        mut scenario: fidl_fuchsia_wlan_internal::TxPowerScenario,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorSetTxPowerScenarioResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#set_tx_power_scenario(self, phy_id, scenario)
    }

    /// Clears any existing TxPowerScenario that has been applied and resets the PHY to use its default TxPowerScenario.
    pub fn r#reset_tx_power_scenario(
        &self,
        mut phy_id: u16,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorResetTxPowerScenarioResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#reset_tx_power_scenario(self, phy_id)
    }

    /// Queries the current TxPowerScenario setting for the specified PHY.
    pub fn r#get_tx_power_scenario(
        &self,
        mut phy_id: u16,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorGetTxPowerScenarioResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#get_tx_power_scenario(self, phy_id)
    }

    /// This will return the current power state of the wlan chip.
    pub fn r#get_power_state(
        &self,
        mut phy_id: u16,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorGetPowerStateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#get_power_state(self, phy_id)
    }

    /// Set the Bluetooth coexistence mode.
    /// Likely errors include:
    ///     * NOT_FOUND: The given phy_id does not exist.
    ///     * NOT_SUPPORTED: The specified BT coexistence mode is not supported.
    pub fn r#set_bt_coexistence_mode(
        &self,
        mut phy_id: u16,
        mut mode: fidl_fuchsia_wlan_internal::BtCoexistenceMode,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorSetBtCoexistenceModeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#set_bt_coexistence_mode(self, phy_id, mode)
    }

    pub fn r#create_iface(
        &self,
        mut payload: &DeviceMonitorCreateIfaceRequest,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorCreateIfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#create_iface(self, payload)
    }

    pub fn r#query_iface(
        &self,
        mut iface_id: u16,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorQueryIfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#query_iface(self, iface_id)
    }

    pub fn r#destroy_iface(
        &self,
        mut req: &DestroyIfaceRequest,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DeviceMonitorProxyInterface::r#destroy_iface(self, req)
    }

    pub fn r#query_iface_capabilities(
        &self,
        mut iface_id: u16,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorQueryIfaceCapabilitiesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#query_iface_capabilities(self, iface_id)
    }

    /// Attempt to establish a new connection to a Client SME.
    /// Connections may be established for the whole lifetime of the SME,
    /// but concurrent connections might lead to unexpected behavior.
    /// Likely errors include:
    ///     * NOT_FOUND: The given iface_id does not exist.
    ///     * NOT_SUPPORTED: The underlying SME is not a Client SME.
    ///     * PEER_CLOSED: The underlying SME is shutting down.
    pub fn r#get_client_sme(
        &self,
        mut iface_id: u16,
        mut sme_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ClientSmeMarker>,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorGetClientSmeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#get_client_sme(self, iface_id, sme_server)
    }

    /// Attempt to establish a new connection to an AP SME.
    /// Connections may be established for the whole lifetime of the SME,
    /// but concurrent connections might lead to unexpected behavior.
    /// Likely errors include:
    ///     * NOT_FOUND: The given iface_id does not exist.
    ///     * NOT_SUPPORTED: The underlying SME is not a Client SME.
    ///     * PEER_CLOSED: The underlying SME is shutting down.
    pub fn r#get_ap_sme(
        &self,
        mut iface_id: u16,
        mut sme_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ApSmeMarker>,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorGetApSmeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#get_ap_sme(self, iface_id, sme_server)
    }

    /// Attempt to establish a new connection to telemetry for an SME.
    /// Connections may be established for the whole lifetime of the SME, and
    /// concurrent connections are safe since this is a read-only API.
    /// Likely errors include:
    ///     * NOT_FOUND: The given iface_id does not exist.
    ///     * NOT_SUPPORTED: The underlying SME is not a Client SME.
    ///     * PEER_CLOSED: The underlying SME is shutting down.
    pub fn r#get_sme_telemetry(
        &self,
        mut iface_id: u16,
        mut telemetry_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::TelemetryMarker>,
    ) -> fidl::client::QueryResponseFut<
        DeviceMonitorGetSmeTelemetryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceMonitorProxyInterface::r#get_sme_telemetry(self, iface_id, telemetry_server)
    }
}

impl DeviceMonitorProxyInterface for DeviceMonitorProxy {
    type ListPhysResponseFut =
        fidl::client::QueryResponseFut<Vec<u16>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#list_phys(&self) -> Self::ListPhysResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<u16>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceMonitorListPhysResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3a08518874196aab,
            >(_buf?)?;
            Ok(_response.phy_list)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u16>>(
            (),
            0x3a08518874196aab,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type GetSupportedMacRolesResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorGetSupportedMacRolesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_supported_mac_roles(&self, mut phy_id: u16) -> Self::GetSupportedMacRolesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorGetSupportedMacRolesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceMonitorGetSupportedMacRolesResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x172b3d2eabd5a14e,
            >(_buf?)?;
            Ok(_response.map(|x| x.supported_mac_roles))
        }
        self.client.send_query_and_decode::<
            DeviceMonitorGetSupportedMacRolesRequest,
            DeviceMonitorGetSupportedMacRolesResult,
        >(
            (phy_id,),
            0x172b3d2eabd5a14e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#watch_devices(
        &self,
        mut watcher: fidl::endpoints::ServerEnd<DeviceWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceMonitorWatchDevicesRequest>(
            (watcher,),
            0x4615941e67e31b8e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#watch_phy_events(
        &self,
        mut watcher: fidl::endpoints::ServerEnd<PhyEventWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceMonitorWatchPhyEventsRequest>(
            (watcher,),
            0x2c5af9d064099745,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetCountryResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorGetCountryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_country(&self, mut phy_id: u16) -> Self::GetCountryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorGetCountryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceMonitorGetCountryResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6f1040bd81bde90e,
            >(_buf?)?;
            Ok(_response.map(|x| x.resp))
        }
        self.client
            .send_query_and_decode::<DeviceMonitorGetCountryRequest, DeviceMonitorGetCountryResult>(
                (phy_id,),
                0x6f1040bd81bde90e,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetCountryResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_country(&self, mut req: &SetCountryRequest) -> Self::SetCountryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceMonitorSetCountryResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xdaa7b77a5a6e71b,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<DeviceMonitorSetCountryRequest, i32>(
            (req,),
            0xdaa7b77a5a6e71b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ClearCountryResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#clear_country(&self, mut req: &ClearCountryRequest) -> Self::ClearCountryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceMonitorClearCountryResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x66714d61103120e9,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<DeviceMonitorClearCountryRequest, i32>(
            (req,),
            0x66714d61103120e9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetPowerSaveModeResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_power_save_mode(
        &self,
        mut req: &SetPowerSaveModeRequest,
    ) -> Self::SetPowerSaveModeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceMonitorSetPowerSaveModeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x62202b4d360533bc,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<DeviceMonitorSetPowerSaveModeRequest, i32>(
            (req,),
            0x62202b4d360533bc,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPowerSaveModeResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorGetPowerSaveModeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_power_save_mode(&self, mut phy_id: u16) -> Self::GetPowerSaveModeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorGetPowerSaveModeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceMonitorGetPowerSaveModeResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x14304d406ada8693,
            >(_buf?)?;
            Ok(_response.map(|x| x.resp))
        }
        self.client.send_query_and_decode::<
            DeviceMonitorGetPowerSaveModeRequest,
            DeviceMonitorGetPowerSaveModeResult,
        >(
            (phy_id,),
            0x14304d406ada8693,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type PowerDownResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorPowerDownResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#power_down(&self, mut phy_id: u16) -> Self::PowerDownResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorPowerDownResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x374ad717fe8902e0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<DeviceMonitorPowerDownRequest, DeviceMonitorPowerDownResult>(
                (phy_id,),
                0x374ad717fe8902e0,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type PowerUpResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorPowerUpResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#power_up(&self, mut phy_id: u16) -> Self::PowerUpResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorPowerUpResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xa2379b639869c17,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<DeviceMonitorPowerUpRequest, DeviceMonitorPowerUpResult>(
                (phy_id,),
                0xa2379b639869c17,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ResetResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorResetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#reset(&self, mut phy_id: u16) -> Self::ResetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorResetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6def240c9f8c6867,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DeviceMonitorResetRequest, DeviceMonitorResetResult>(
            (phy_id,),
            0x6def240c9f8c6867,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetTxPowerScenarioResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorSetTxPowerScenarioResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_tx_power_scenario(
        &self,
        mut phy_id: u16,
        mut scenario: fidl_fuchsia_wlan_internal::TxPowerScenario,
    ) -> Self::SetTxPowerScenarioResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorSetTxPowerScenarioResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7c51443a985934fd,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DeviceMonitorSetTxPowerScenarioRequest,
            DeviceMonitorSetTxPowerScenarioResult,
        >(
            (phy_id, scenario,),
            0x7c51443a985934fd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ResetTxPowerScenarioResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorResetTxPowerScenarioResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#reset_tx_power_scenario(&self, mut phy_id: u16) -> Self::ResetTxPowerScenarioResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorResetTxPowerScenarioResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4790357c9cdddc4a,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DeviceMonitorResetTxPowerScenarioRequest,
            DeviceMonitorResetTxPowerScenarioResult,
        >(
            (phy_id,),
            0x4790357c9cdddc4a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTxPowerScenarioResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorGetTxPowerScenarioResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_tx_power_scenario(&self, mut phy_id: u16) -> Self::GetTxPowerScenarioResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorGetTxPowerScenarioResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceMonitorGetTxPowerScenarioResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x555fb197f90e9830,
            >(_buf?)?;
            Ok(_response.map(|x| x.scenario))
        }
        self.client.send_query_and_decode::<
            DeviceMonitorGetTxPowerScenarioRequest,
            DeviceMonitorGetTxPowerScenarioResult,
        >(
            (phy_id,),
            0x555fb197f90e9830,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPowerStateResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorGetPowerStateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_power_state(&self, mut phy_id: u16) -> Self::GetPowerStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorGetPowerStateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceMonitorGetPowerStateResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x58cf95c5bbbe3f,
            >(_buf?)?;
            Ok(_response.map(|x| x.power_on))
        }
        self.client.send_query_and_decode::<
            DeviceMonitorGetPowerStateRequest,
            DeviceMonitorGetPowerStateResult,
        >(
            (phy_id,),
            0x58cf95c5bbbe3f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetBtCoexistenceModeResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorSetBtCoexistenceModeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_bt_coexistence_mode(
        &self,
        mut phy_id: u16,
        mut mode: fidl_fuchsia_wlan_internal::BtCoexistenceMode,
    ) -> Self::SetBtCoexistenceModeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorSetBtCoexistenceModeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x97539596c9a79c7,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DeviceMonitorSetBtCoexistenceModeRequest,
            DeviceMonitorSetBtCoexistenceModeResult,
        >(
            (phy_id, mode,),
            0x97539596c9a79c7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CreateIfaceResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorCreateIfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_iface(
        &self,
        mut payload: &DeviceMonitorCreateIfaceRequest,
    ) -> Self::CreateIfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorCreateIfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceMonitorCreateIfaceResponse, DeviceMonitorError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1e1d30c24c0ec144,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DeviceMonitorCreateIfaceRequest,
            DeviceMonitorCreateIfaceResult,
        >(
            payload,
            0x1e1d30c24c0ec144,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryIfaceResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorQueryIfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query_iface(&self, mut iface_id: u16) -> Self::QueryIfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorQueryIfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceMonitorQueryIfaceResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1a48c4a2b86259ef,
            >(_buf?)?;
            Ok(_response.map(|x| x.resp))
        }
        self.client
            .send_query_and_decode::<DeviceMonitorQueryIfaceRequest, DeviceMonitorQueryIfaceResult>(
                (iface_id,),
                0x1a48c4a2b86259ef,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type DestroyIfaceResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#destroy_iface(&self, mut req: &DestroyIfaceRequest) -> Self::DestroyIfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceMonitorDestroyIfaceResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4c77982c1616a3b0,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<DeviceMonitorDestroyIfaceRequest, i32>(
            (req,),
            0x4c77982c1616a3b0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryIfaceCapabilitiesResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorQueryIfaceCapabilitiesResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#query_iface_capabilities(
        &self,
        mut iface_id: u16,
    ) -> Self::QueryIfaceCapabilitiesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorQueryIfaceCapabilitiesResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DeviceMonitorQueryIfaceCapabilitiesResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x37e8b884766de0f8,
            >(_buf?)?;
            Ok(_response.map(|x| x.apf_support))
        }
        self.client.send_query_and_decode::<
            DeviceMonitorQueryIfaceCapabilitiesRequest,
            DeviceMonitorQueryIfaceCapabilitiesResult,
        >(
            (iface_id,),
            0x37e8b884766de0f8,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetClientSmeResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorGetClientSmeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_client_sme(
        &self,
        mut iface_id: u16,
        mut sme_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ClientSmeMarker>,
    ) -> Self::GetClientSmeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorGetClientSmeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1b056c379ca98273,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DeviceMonitorGetClientSmeRequest,
            DeviceMonitorGetClientSmeResult,
        >(
            (iface_id, sme_server,),
            0x1b056c379ca98273,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetApSmeResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorGetApSmeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ap_sme(
        &self,
        mut iface_id: u16,
        mut sme_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ApSmeMarker>,
    ) -> Self::GetApSmeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorGetApSmeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x754de680c4318c52,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<DeviceMonitorGetApSmeRequest, DeviceMonitorGetApSmeResult>(
                (iface_id, sme_server),
                0x754de680c4318c52,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetSmeTelemetryResponseFut = fidl::client::QueryResponseFut<
        DeviceMonitorGetSmeTelemetryResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_sme_telemetry(
        &self,
        mut iface_id: u16,
        mut telemetry_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::TelemetryMarker>,
    ) -> Self::GetSmeTelemetryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceMonitorGetSmeTelemetryResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1baf42b003f7452a,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DeviceMonitorGetSmeTelemetryRequest,
            DeviceMonitorGetSmeTelemetryResult,
        >(
            (iface_id, telemetry_server,),
            0x1baf42b003f7452a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DeviceMonitorRequestStream {
    type Protocol = DeviceMonitorMarker;
    type ControlHandle = DeviceMonitorControlHandle;

    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 {
        DeviceMonitorControlHandle { 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 DeviceMonitorRequestStream {
    type Item = Result<DeviceMonitorRequest, 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 DeviceMonitorRequestStream 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 {
                    0x3a08518874196aab => {
                        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 =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::ListPhys {
                            responder: DeviceMonitorListPhysResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x129e758fb8e0b113 => {
                        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 =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::ListIfaces {
                            responder: DeviceMonitorListIfacesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x172b3d2eabd5a14e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorGetSupportedMacRolesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorGetSupportedMacRolesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::GetSupportedMacRoles {
                            phy_id: req.phy_id,

                            responder: DeviceMonitorGetSupportedMacRolesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4615941e67e31b8e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorWatchDevicesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorWatchDevicesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::WatchDevices {
                            watcher: req.watcher,

                            control_handle,
                        })
                    }
                    0x2c5af9d064099745 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorWatchPhyEventsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorWatchPhyEventsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::WatchPhyEvents {
                            watcher: req.watcher,

                            control_handle,
                        })
                    }
                    0x6f1040bd81bde90e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorGetCountryRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorGetCountryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::GetCountry {
                            phy_id: req.phy_id,

                            responder: DeviceMonitorGetCountryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xdaa7b77a5a6e71b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorSetCountryRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorSetCountryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::SetCountry {
                            req: req.req,

                            responder: DeviceMonitorSetCountryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x66714d61103120e9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorClearCountryRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorClearCountryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::ClearCountry {
                            req: req.req,

                            responder: DeviceMonitorClearCountryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x62202b4d360533bc => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorSetPowerSaveModeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorSetPowerSaveModeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::SetPowerSaveMode {
                            req: req.req,

                            responder: DeviceMonitorSetPowerSaveModeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x14304d406ada8693 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorGetPowerSaveModeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorGetPowerSaveModeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::GetPowerSaveMode {
                            phy_id: req.phy_id,

                            responder: DeviceMonitorGetPowerSaveModeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x374ad717fe8902e0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorPowerDownRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorPowerDownRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::PowerDown {
                            phy_id: req.phy_id,

                            responder: DeviceMonitorPowerDownResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xa2379b639869c17 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorPowerUpRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorPowerUpRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::PowerUp {
                            phy_id: req.phy_id,

                            responder: DeviceMonitorPowerUpResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6def240c9f8c6867 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorResetRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorResetRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::Reset {
                            phy_id: req.phy_id,

                            responder: DeviceMonitorResetResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7c51443a985934fd => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorSetTxPowerScenarioRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorSetTxPowerScenarioRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::SetTxPowerScenario {
                            phy_id: req.phy_id,
                            scenario: req.scenario,

                            responder: DeviceMonitorSetTxPowerScenarioResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4790357c9cdddc4a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorResetTxPowerScenarioRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorResetTxPowerScenarioRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::ResetTxPowerScenario {
                            phy_id: req.phy_id,

                            responder: DeviceMonitorResetTxPowerScenarioResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x555fb197f90e9830 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorGetTxPowerScenarioRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorGetTxPowerScenarioRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::GetTxPowerScenario {
                            phy_id: req.phy_id,

                            responder: DeviceMonitorGetTxPowerScenarioResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x58cf95c5bbbe3f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorGetPowerStateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorGetPowerStateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::GetPowerState {
                            phy_id: req.phy_id,

                            responder: DeviceMonitorGetPowerStateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x97539596c9a79c7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorSetBtCoexistenceModeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorSetBtCoexistenceModeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::SetBtCoexistenceMode {
                            phy_id: req.phy_id,
                            mode: req.mode,

                            responder: DeviceMonitorSetBtCoexistenceModeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1e1d30c24c0ec144 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorCreateIfaceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorCreateIfaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::CreateIface {
                            payload: req,
                            responder: DeviceMonitorCreateIfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1a48c4a2b86259ef => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorQueryIfaceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorQueryIfaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::QueryIface {
                            iface_id: req.iface_id,

                            responder: DeviceMonitorQueryIfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4c77982c1616a3b0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorDestroyIfaceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorDestroyIfaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::DestroyIface {
                            req: req.req,

                            responder: DeviceMonitorDestroyIfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x37e8b884766de0f8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorQueryIfaceCapabilitiesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorQueryIfaceCapabilitiesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::QueryIfaceCapabilities {
                            iface_id: req.iface_id,

                            responder: DeviceMonitorQueryIfaceCapabilitiesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1b056c379ca98273 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorGetClientSmeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorGetClientSmeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::GetClientSme {
                            iface_id: req.iface_id,
                            sme_server: req.sme_server,

                            responder: DeviceMonitorGetClientSmeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x754de680c4318c52 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorGetApSmeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorGetApSmeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::GetApSme {
                            iface_id: req.iface_id,
                            sme_server: req.sme_server,

                            responder: DeviceMonitorGetApSmeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1baf42b003f7452a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceMonitorGetSmeTelemetryRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceMonitorGetSmeTelemetryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceMonitorControlHandle { inner: this.inner.clone() };
                        Ok(DeviceMonitorRequest::GetSmeTelemetry {
                            iface_id: req.iface_id,
                            telemetry_server: req.telemetry_server,

                            responder: DeviceMonitorGetSmeTelemetryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DeviceMonitorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum DeviceMonitorRequest {
    ListPhys {
        responder: DeviceMonitorListPhysResponder,
    },
    ListIfaces {
        responder: DeviceMonitorListIfacesResponder,
    },
    GetSupportedMacRoles {
        phy_id: u16,
        responder: DeviceMonitorGetSupportedMacRolesResponder,
    },
    WatchDevices {
        watcher: fidl::endpoints::ServerEnd<DeviceWatcherMarker>,
        control_handle: DeviceMonitorControlHandle,
    },
    WatchPhyEvents {
        watcher: fidl::endpoints::ServerEnd<PhyEventWatcherMarker>,
        control_handle: DeviceMonitorControlHandle,
    },
    GetCountry {
        phy_id: u16,
        responder: DeviceMonitorGetCountryResponder,
    },
    SetCountry {
        req: SetCountryRequest,
        responder: DeviceMonitorSetCountryResponder,
    },
    ClearCountry {
        req: ClearCountryRequest,
        responder: DeviceMonitorClearCountryResponder,
    },
    SetPowerSaveMode {
        req: SetPowerSaveModeRequest,
        responder: DeviceMonitorSetPowerSaveModeResponder,
    },
    GetPowerSaveMode {
        phy_id: u16,
        responder: DeviceMonitorGetPowerSaveModeResponder,
    },
    /// All interfaces should be deleted before calling this method. If supported, the
    /// wlan driver will power down the wlan chip. Refer to wlan.phyimpl fidl for more details.
    PowerDown {
        phy_id: u16,
        responder: DeviceMonitorPowerDownResponder,
    },
    /// If supported, the wlan driver will power up the wlan chip. Refer to wlan.phyimpl fidl
    /// for more details.
    PowerUp {
        phy_id: u16,
        responder: DeviceMonitorPowerUpResponder,
    },
    /// If supported, the wlan driver will reset the wlan chip. An attempt is made to delete
    /// any existing interfaces. Refer to wlan.phyimpl fidl for more details.
    Reset {
        phy_id: u16,
        responder: DeviceMonitorResetResponder,
    },
    /// Applies the provided TxPowerScenario to the specified PHY.
    SetTxPowerScenario {
        phy_id: u16,
        scenario: fidl_fuchsia_wlan_internal::TxPowerScenario,
        responder: DeviceMonitorSetTxPowerScenarioResponder,
    },
    /// Clears any existing TxPowerScenario that has been applied and resets the PHY to use its default TxPowerScenario.
    ResetTxPowerScenario {
        phy_id: u16,
        responder: DeviceMonitorResetTxPowerScenarioResponder,
    },
    /// Queries the current TxPowerScenario setting for the specified PHY.
    GetTxPowerScenario {
        phy_id: u16,
        responder: DeviceMonitorGetTxPowerScenarioResponder,
    },
    /// This will return the current power state of the wlan chip.
    GetPowerState {
        phy_id: u16,
        responder: DeviceMonitorGetPowerStateResponder,
    },
    /// Set the Bluetooth coexistence mode.
    /// Likely errors include:
    ///     * NOT_FOUND: The given phy_id does not exist.
    ///     * NOT_SUPPORTED: The specified BT coexistence mode is not supported.
    SetBtCoexistenceMode {
        phy_id: u16,
        mode: fidl_fuchsia_wlan_internal::BtCoexistenceMode,
        responder: DeviceMonitorSetBtCoexistenceModeResponder,
    },
    CreateIface {
        payload: DeviceMonitorCreateIfaceRequest,
        responder: DeviceMonitorCreateIfaceResponder,
    },
    QueryIface {
        iface_id: u16,
        responder: DeviceMonitorQueryIfaceResponder,
    },
    DestroyIface {
        req: DestroyIfaceRequest,
        responder: DeviceMonitorDestroyIfaceResponder,
    },
    QueryIfaceCapabilities {
        iface_id: u16,
        responder: DeviceMonitorQueryIfaceCapabilitiesResponder,
    },
    /// Attempt to establish a new connection to a Client SME.
    /// Connections may be established for the whole lifetime of the SME,
    /// but concurrent connections might lead to unexpected behavior.
    /// Likely errors include:
    ///     * NOT_FOUND: The given iface_id does not exist.
    ///     * NOT_SUPPORTED: The underlying SME is not a Client SME.
    ///     * PEER_CLOSED: The underlying SME is shutting down.
    GetClientSme {
        iface_id: u16,
        sme_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ClientSmeMarker>,
        responder: DeviceMonitorGetClientSmeResponder,
    },
    /// Attempt to establish a new connection to an AP SME.
    /// Connections may be established for the whole lifetime of the SME,
    /// but concurrent connections might lead to unexpected behavior.
    /// Likely errors include:
    ///     * NOT_FOUND: The given iface_id does not exist.
    ///     * NOT_SUPPORTED: The underlying SME is not a Client SME.
    ///     * PEER_CLOSED: The underlying SME is shutting down.
    GetApSme {
        iface_id: u16,
        sme_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ApSmeMarker>,
        responder: DeviceMonitorGetApSmeResponder,
    },
    /// Attempt to establish a new connection to telemetry for an SME.
    /// Connections may be established for the whole lifetime of the SME, and
    /// concurrent connections are safe since this is a read-only API.
    /// Likely errors include:
    ///     * NOT_FOUND: The given iface_id does not exist.
    ///     * NOT_SUPPORTED: The underlying SME is not a Client SME.
    ///     * PEER_CLOSED: The underlying SME is shutting down.
    GetSmeTelemetry {
        iface_id: u16,
        telemetry_server: fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::TelemetryMarker>,
        responder: DeviceMonitorGetSmeTelemetryResponder,
    },
}

impl DeviceMonitorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_list_phys(self) -> Option<(DeviceMonitorListPhysResponder)> {
        if let DeviceMonitorRequest::ListPhys { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_list_ifaces(self) -> Option<(DeviceMonitorListIfacesResponder)> {
        if let DeviceMonitorRequest::ListIfaces { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_supported_mac_roles(
        self,
    ) -> Option<(u16, DeviceMonitorGetSupportedMacRolesResponder)> {
        if let DeviceMonitorRequest::GetSupportedMacRoles { phy_id, responder } = self {
            Some((phy_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_devices(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<DeviceWatcherMarker>, DeviceMonitorControlHandle)> {
        if let DeviceMonitorRequest::WatchDevices { watcher, control_handle } = self {
            Some((watcher, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_phy_events(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<PhyEventWatcherMarker>, DeviceMonitorControlHandle)>
    {
        if let DeviceMonitorRequest::WatchPhyEvents { watcher, control_handle } = self {
            Some((watcher, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_country(self) -> Option<(u16, DeviceMonitorGetCountryResponder)> {
        if let DeviceMonitorRequest::GetCountry { phy_id, responder } = self {
            Some((phy_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_country(self) -> Option<(SetCountryRequest, DeviceMonitorSetCountryResponder)> {
        if let DeviceMonitorRequest::SetCountry { req, responder } = self {
            Some((req, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clear_country(
        self,
    ) -> Option<(ClearCountryRequest, DeviceMonitorClearCountryResponder)> {
        if let DeviceMonitorRequest::ClearCountry { req, responder } = self {
            Some((req, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_power_save_mode(
        self,
    ) -> Option<(SetPowerSaveModeRequest, DeviceMonitorSetPowerSaveModeResponder)> {
        if let DeviceMonitorRequest::SetPowerSaveMode { req, responder } = self {
            Some((req, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_power_save_mode(self) -> Option<(u16, DeviceMonitorGetPowerSaveModeResponder)> {
        if let DeviceMonitorRequest::GetPowerSaveMode { phy_id, responder } = self {
            Some((phy_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_power_down(self) -> Option<(u16, DeviceMonitorPowerDownResponder)> {
        if let DeviceMonitorRequest::PowerDown { phy_id, responder } = self {
            Some((phy_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_power_up(self) -> Option<(u16, DeviceMonitorPowerUpResponder)> {
        if let DeviceMonitorRequest::PowerUp { phy_id, responder } = self {
            Some((phy_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reset(self) -> Option<(u16, DeviceMonitorResetResponder)> {
        if let DeviceMonitorRequest::Reset { phy_id, responder } = self {
            Some((phy_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_tx_power_scenario(
        self,
    ) -> Option<(
        u16,
        fidl_fuchsia_wlan_internal::TxPowerScenario,
        DeviceMonitorSetTxPowerScenarioResponder,
    )> {
        if let DeviceMonitorRequest::SetTxPowerScenario { phy_id, scenario, responder } = self {
            Some((phy_id, scenario, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reset_tx_power_scenario(
        self,
    ) -> Option<(u16, DeviceMonitorResetTxPowerScenarioResponder)> {
        if let DeviceMonitorRequest::ResetTxPowerScenario { phy_id, responder } = self {
            Some((phy_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tx_power_scenario(
        self,
    ) -> Option<(u16, DeviceMonitorGetTxPowerScenarioResponder)> {
        if let DeviceMonitorRequest::GetTxPowerScenario { phy_id, responder } = self {
            Some((phy_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_power_state(self) -> Option<(u16, DeviceMonitorGetPowerStateResponder)> {
        if let DeviceMonitorRequest::GetPowerState { phy_id, responder } = self {
            Some((phy_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_bt_coexistence_mode(
        self,
    ) -> Option<(
        u16,
        fidl_fuchsia_wlan_internal::BtCoexistenceMode,
        DeviceMonitorSetBtCoexistenceModeResponder,
    )> {
        if let DeviceMonitorRequest::SetBtCoexistenceMode { phy_id, mode, responder } = self {
            Some((phy_id, mode, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_iface(
        self,
    ) -> Option<(DeviceMonitorCreateIfaceRequest, DeviceMonitorCreateIfaceResponder)> {
        if let DeviceMonitorRequest::CreateIface { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_iface(self) -> Option<(u16, DeviceMonitorQueryIfaceResponder)> {
        if let DeviceMonitorRequest::QueryIface { iface_id, responder } = self {
            Some((iface_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_destroy_iface(
        self,
    ) -> Option<(DestroyIfaceRequest, DeviceMonitorDestroyIfaceResponder)> {
        if let DeviceMonitorRequest::DestroyIface { req, responder } = self {
            Some((req, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query_iface_capabilities(
        self,
    ) -> Option<(u16, DeviceMonitorQueryIfaceCapabilitiesResponder)> {
        if let DeviceMonitorRequest::QueryIfaceCapabilities { iface_id, responder } = self {
            Some((iface_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_client_sme(
        self,
    ) -> Option<(
        u16,
        fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ClientSmeMarker>,
        DeviceMonitorGetClientSmeResponder,
    )> {
        if let DeviceMonitorRequest::GetClientSme { iface_id, sme_server, responder } = self {
            Some((iface_id, sme_server, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ap_sme(
        self,
    ) -> Option<(
        u16,
        fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ApSmeMarker>,
        DeviceMonitorGetApSmeResponder,
    )> {
        if let DeviceMonitorRequest::GetApSme { iface_id, sme_server, responder } = self {
            Some((iface_id, sme_server, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_sme_telemetry(
        self,
    ) -> Option<(
        u16,
        fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::TelemetryMarker>,
        DeviceMonitorGetSmeTelemetryResponder,
    )> {
        if let DeviceMonitorRequest::GetSmeTelemetry { iface_id, telemetry_server, responder } =
            self
        {
            Some((iface_id, telemetry_server, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DeviceMonitorRequest::ListPhys { .. } => "list_phys",
            DeviceMonitorRequest::ListIfaces { .. } => "list_ifaces",
            DeviceMonitorRequest::GetSupportedMacRoles { .. } => "get_supported_mac_roles",
            DeviceMonitorRequest::WatchDevices { .. } => "watch_devices",
            DeviceMonitorRequest::WatchPhyEvents { .. } => "watch_phy_events",
            DeviceMonitorRequest::GetCountry { .. } => "get_country",
            DeviceMonitorRequest::SetCountry { .. } => "set_country",
            DeviceMonitorRequest::ClearCountry { .. } => "clear_country",
            DeviceMonitorRequest::SetPowerSaveMode { .. } => "set_power_save_mode",
            DeviceMonitorRequest::GetPowerSaveMode { .. } => "get_power_save_mode",
            DeviceMonitorRequest::PowerDown { .. } => "power_down",
            DeviceMonitorRequest::PowerUp { .. } => "power_up",
            DeviceMonitorRequest::Reset { .. } => "reset",
            DeviceMonitorRequest::SetTxPowerScenario { .. } => "set_tx_power_scenario",
            DeviceMonitorRequest::ResetTxPowerScenario { .. } => "reset_tx_power_scenario",
            DeviceMonitorRequest::GetTxPowerScenario { .. } => "get_tx_power_scenario",
            DeviceMonitorRequest::GetPowerState { .. } => "get_power_state",
            DeviceMonitorRequest::SetBtCoexistenceMode { .. } => "set_bt_coexistence_mode",
            DeviceMonitorRequest::CreateIface { .. } => "create_iface",
            DeviceMonitorRequest::QueryIface { .. } => "query_iface",
            DeviceMonitorRequest::DestroyIface { .. } => "destroy_iface",
            DeviceMonitorRequest::QueryIfaceCapabilities { .. } => "query_iface_capabilities",
            DeviceMonitorRequest::GetClientSme { .. } => "get_client_sme",
            DeviceMonitorRequest::GetApSme { .. } => "get_ap_sme",
            DeviceMonitorRequest::GetSmeTelemetry { .. } => "get_sme_telemetry",
        }
    }
}

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

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

impl fidl::endpoints::ControlHandle for DeviceMonitorControlHandle {
    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 DeviceMonitorControlHandle {}

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

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

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

    fn send_raw(&self, mut phy_list: &[u16]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceMonitorListPhysResponse>(
            (phy_list,),
            self.tx_id,
            0x3a08518874196aab,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut iface_list: &[u16]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceMonitorListIfacesResponse>(
            (iface_list,),
            self.tx_id,
            0x129e758fb8e0b113,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

    fn control_handle(&self) -> &DeviceMonitorControlHandle {
        &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 DeviceMonitorGetSupportedMacRolesResponder {
    /// 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::WlanMacRole], 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::WlanMacRole], 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::WlanMacRole], i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            DeviceMonitorGetSupportedMacRolesResponse,
            i32,
        >>(
            result.map(|supported_mac_roles| (supported_mac_roles,)),
            self.tx_id,
            0x172b3d2eabd5a14e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceMonitorSetCountryResponse>(
            (status,),
            self.tx_id,
            0xdaa7b77a5a6e71b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceMonitorClearCountryResponse>(
            (status,),
            self.tx_id,
            0x66714d61103120e9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceMonitorSetPowerSaveModeResponse>(
            (status,),
            self.tx_id,
            0x62202b4d360533bc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn control_handle(&self) -> &DeviceMonitorControlHandle {
        &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 DeviceMonitorGetTxPowerScenarioResponder {
    /// 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_internal::TxPowerScenario, 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_internal::TxPowerScenario, 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_internal::TxPowerScenario, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            DeviceMonitorGetTxPowerScenarioResponse,
            i32,
        >>(
            result.map(|scenario| (scenario,)),
            self.tx_id,
            0x555fb197f90e9830,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceMonitorDestroyIfaceResponse>(
            (status,),
            self.tx_id,
            0x4c77982c1616a3b0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

    fn control_handle(&self) -> &DeviceMonitorControlHandle {
        &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 DeviceMonitorQueryIfaceCapabilitiesResponder {
    /// 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::ApfPacketFilterSupport, 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::ApfPacketFilterSupport, 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::ApfPacketFilterSupport, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            DeviceMonitorQueryIfaceCapabilitiesResponse,
            i32,
        >>(
            result.map(|apf_support| (apf_support,)),
            self.tx_id,
            0x37e8b884766de0f8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for DeviceWatcherMarker {
    type Proxy = DeviceWatcherProxy;
    type RequestStream = DeviceWatcherRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DeviceWatcherSynchronousProxy;

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

pub trait DeviceWatcherProxyInterface: Send + Sync {}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DeviceWatcherSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DeviceWatcherSynchronousProxy {
    type Proxy = DeviceWatcherProxy;
    type Protocol = DeviceWatcherMarker;

    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 DeviceWatcherSynchronousProxy {
    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<DeviceWatcherEvent, fidl::Error> {
        DeviceWatcherEvent::decode(self.client.wait_for_event::<DeviceWatcherMarker>(deadline)?)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DeviceWatcherProxy {
    type Protocol = DeviceWatcherMarker;

    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 DeviceWatcherProxy {
    /// Create a new Proxy for fuchsia.wlan.device.service/DeviceWatcher.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DeviceWatcherMarker 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) -> DeviceWatcherEventStream {
        DeviceWatcherEventStream { event_receiver: self.client.take_event_receiver() }
    }
}

impl DeviceWatcherProxyInterface for DeviceWatcherProxy {}

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

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

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

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

#[derive(Debug)]
pub enum DeviceWatcherEvent {
    OnPhyAdded { phy_id: u16 },
    OnPhyRemoved { phy_id: u16 },
    OnIfaceAdded { iface_id: u16 },
    OnIfaceRemoved { iface_id: u16 },
}

impl DeviceWatcherEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_phy_added(self) -> Option<u16> {
        if let DeviceWatcherEvent::OnPhyAdded { phy_id } = self { Some((phy_id)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_phy_removed(self) -> Option<u16> {
        if let DeviceWatcherEvent::OnPhyRemoved { phy_id } = self { Some((phy_id)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_iface_added(self) -> Option<u16> {
        if let DeviceWatcherEvent::OnIfaceAdded { iface_id } = self {
            Some((iface_id))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_iface_removed(self) -> Option<u16> {
        if let DeviceWatcherEvent::OnIfaceRemoved { iface_id } = self {
            Some((iface_id))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`DeviceWatcherEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<DeviceWatcherEvent, 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 {
            0x771c58e0bd059f86 => {
                let mut out = fidl::new_empty!(
                    DeviceWatcherOnPhyAddedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceWatcherOnPhyAddedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((DeviceWatcherEvent::OnPhyAdded { phy_id: out.phy_id }))
            }
            0x4ad72b96ccb7cff6 => {
                let mut out = fidl::new_empty!(
                    DeviceWatcherOnPhyRemovedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceWatcherOnPhyRemovedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((DeviceWatcherEvent::OnPhyRemoved { phy_id: out.phy_id }))
            }
            0x6ee685e4aa1f31d8 => {
                let mut out = fidl::new_empty!(
                    DeviceWatcherOnIfaceAddedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceWatcherOnIfaceAddedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((DeviceWatcherEvent::OnIfaceAdded { iface_id: out.iface_id }))
            }
            0x3b771b1fce38c291 => {
                let mut out = fidl::new_empty!(
                    DeviceWatcherOnIfaceRemovedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceWatcherOnIfaceRemovedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((DeviceWatcherEvent::OnIfaceRemoved { iface_id: out.iface_id }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <DeviceWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for DeviceWatcherRequestStream {
    type Protocol = DeviceWatcherMarker;
    type ControlHandle = DeviceWatcherControlHandle;

    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 {
        DeviceWatcherControlHandle { 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 DeviceWatcherRequestStream {
    type Item = Result<DeviceWatcherRequest, 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 DeviceWatcherRequestStream 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 {
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DeviceWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

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

impl DeviceWatcherRequest {
    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {}
    }
}

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

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

impl fidl::endpoints::ControlHandle for DeviceWatcherControlHandle {
    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 DeviceWatcherControlHandle {
    pub fn send_on_phy_added(&self, mut phy_id: u16) -> Result<(), fidl::Error> {
        self.inner.send::<DeviceWatcherOnPhyAddedRequest>(
            (phy_id,),
            0,
            0x771c58e0bd059f86,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_phy_removed(&self, mut phy_id: u16) -> Result<(), fidl::Error> {
        self.inner.send::<DeviceWatcherOnPhyRemovedRequest>(
            (phy_id,),
            0,
            0x4ad72b96ccb7cff6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_iface_added(&self, mut iface_id: u16) -> Result<(), fidl::Error> {
        self.inner.send::<DeviceWatcherOnIfaceAddedRequest>(
            (iface_id,),
            0,
            0x6ee685e4aa1f31d8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_iface_removed(&self, mut iface_id: u16) -> Result<(), fidl::Error> {
        self.inner.send::<DeviceWatcherOnIfaceRemovedRequest>(
            (iface_id,),
            0,
            0x3b771b1fce38c291,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for PhyEventWatcherMarker {
    type Proxy = PhyEventWatcherProxy;
    type RequestStream = PhyEventWatcherRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PhyEventWatcherSynchronousProxy;

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

pub trait PhyEventWatcherProxyInterface: Send + Sync {}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PhyEventWatcherSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PhyEventWatcherSynchronousProxy {
    type Proxy = PhyEventWatcherProxy;
    type Protocol = PhyEventWatcherMarker;

    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 PhyEventWatcherSynchronousProxy {
    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<PhyEventWatcherEvent, fidl::Error> {
        PhyEventWatcherEvent::decode(self.client.wait_for_event::<PhyEventWatcherMarker>(deadline)?)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PhyEventWatcherProxy {
    type Protocol = PhyEventWatcherMarker;

    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 PhyEventWatcherProxy {
    /// Create a new Proxy for fuchsia.wlan.device.service/PhyEventWatcher.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PhyEventWatcherMarker 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) -> PhyEventWatcherEventStream {
        PhyEventWatcherEventStream { event_receiver: self.client.take_event_receiver() }
    }
}

impl PhyEventWatcherProxyInterface for PhyEventWatcherProxy {}

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

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

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

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

#[derive(Debug)]
pub enum PhyEventWatcherEvent {
    OnCriticalError {
        phy_id: u16,
        reason_code: fidl_fuchsia_wlan_internal::CriticalErrorReason,
    },
    OnCountryCodeChange {
        phy_id: u16,
        alpha2: [u8; 2],
    },
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl PhyEventWatcherEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_critical_error(
        self,
    ) -> Option<(u16, fidl_fuchsia_wlan_internal::CriticalErrorReason)> {
        if let PhyEventWatcherEvent::OnCriticalError { phy_id, reason_code } = self {
            Some((phy_id, reason_code))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_country_code_change(self) -> Option<(u16, [u8; 2])> {
        if let PhyEventWatcherEvent::OnCountryCodeChange { phy_id, alpha2 } = self {
            Some((phy_id, alpha2))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`PhyEventWatcherEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<PhyEventWatcherEvent, 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 {
            0x609a325d54f9e6ac => {
                let mut out = fidl::new_empty!(
                    PhyEventWatcherOnCriticalErrorRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PhyEventWatcherOnCriticalErrorRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((PhyEventWatcherEvent::OnCriticalError {
                    phy_id: out.phy_id,
                    reason_code: out.reason_code,
                }))
            }
            0x781d791772be33ed => {
                let mut out = fidl::new_empty!(
                    PhyEventWatcherOnCountryCodeChangeRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PhyEventWatcherOnCountryCodeChangeRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((PhyEventWatcherEvent::OnCountryCodeChange {
                    phy_id: out.phy_id,
                    alpha2: out.alpha2,
                }))
            }
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(PhyEventWatcherEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <PhyEventWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for PhyEventWatcherRequestStream {
    type Protocol = PhyEventWatcherMarker;
    type ControlHandle = PhyEventWatcherControlHandle;

    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 {
        PhyEventWatcherControlHandle { 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 PhyEventWatcherRequestStream {
    type Item = Result<PhyEventWatcherRequest, 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 PhyEventWatcherRequestStream 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 {
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(PhyEventWatcherRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: PhyEventWatcherControlHandle {
                                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(PhyEventWatcherRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: PhyEventWatcherControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <PhyEventWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum PhyEventWatcherRequest {
    /// 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: PhyEventWatcherControlHandle,
        method_type: fidl::MethodType,
    },
}

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

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

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

impl fidl::endpoints::ControlHandle for PhyEventWatcherControlHandle {
    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 PhyEventWatcherControlHandle {
    pub fn send_on_critical_error(
        &self,
        mut phy_id: u16,
        mut reason_code: fidl_fuchsia_wlan_internal::CriticalErrorReason,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<PhyEventWatcherOnCriticalErrorRequest>(
            (phy_id, reason_code),
            0,
            0x609a325d54f9e6ac,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_country_code_change(
        &self,
        mut phy_id: u16,
        mut alpha2: &[u8; 2],
    ) -> Result<(), fidl::Error> {
        self.inner.send::<PhyEventWatcherOnCountryCodeChangeRequest>(
            (phy_id, alpha2),
            0,
            0x781d791772be33ed,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DeviceMonitorGetApSmeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                iface_id: fidl::new_empty!(u16, fidl::encoding::DefaultFuchsiaResourceDialect),
                sme_server: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ApSmeMarker>,
                    >,
                    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 u32).read_unaligned() };
            let mask = 0xffff0000u32;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                u16,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.iface_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ApSmeMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.sme_server,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DeviceMonitorGetClientSmeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                iface_id: fidl::new_empty!(u16, fidl::encoding::DefaultFuchsiaResourceDialect),
                sme_server: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ClientSmeMarker>,
                    >,
                    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 u32).read_unaligned() };
            let mask = 0xffff0000u32;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                u16,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.iface_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::ClientSmeMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.sme_server,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DeviceMonitorGetSmeTelemetryRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                iface_id: fidl::new_empty!(u16, fidl::encoding::DefaultFuchsiaResourceDialect),
                telemetry_server: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::TelemetryMarker>,
                    >,
                    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 u32).read_unaligned() };
            let mask = 0xffff0000u32;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                u16,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.iface_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_wlan_sme::TelemetryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.telemetry_server,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DeviceMonitorWatchDevicesRequest {
        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 DeviceMonitorWatchDevicesRequest {
        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<
            DeviceMonitorWatchDevicesRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DeviceMonitorWatchDevicesRequest
    {
        #[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::<DeviceMonitorWatchDevicesRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceMonitorWatchDevicesRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceWatcherMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.watcher),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            DeviceMonitorWatchDevicesRequest,
            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::<DeviceMonitorWatchDevicesRequest>(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 DeviceMonitorWatchDevicesRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceWatcherMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for DeviceMonitorWatchPhyEventsRequest {
        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 DeviceMonitorWatchPhyEventsRequest {
        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<
            DeviceMonitorWatchPhyEventsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DeviceMonitorWatchPhyEventsRequest
    {
        #[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::<DeviceMonitorWatchPhyEventsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceMonitorWatchPhyEventsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PhyEventWatcherMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.watcher),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PhyEventWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            DeviceMonitorWatchPhyEventsRequest,
            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::<DeviceMonitorWatchPhyEventsRequest>(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 DeviceMonitorWatchPhyEventsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PhyEventWatcherMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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