fidl_fuchsia_hardware_bluetooth/

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

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

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

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

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

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

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

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

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VendorOpenHciTransportResponse {
    pub channel: fidl::endpoints::ClientEnd<HciTransportMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VendorOpenHciResponse {
    pub channel: fidl::endpoints::ClientEnd<HciMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VendorOpenSnoopResponse {
    pub channel: fidl::endpoints::ClientEnd<SnoopMarker>,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct HciTransportConfigureScoRequest {
    /// Required.
    pub coding_format: Option<ScoCodingFormat>,
    /// Required.
    pub encoding: Option<ScoEncoding>,
    /// Required.
    pub sample_rate: Option<ScoSampleRate>,
    /// Required.
    pub connection: Option<fidl::endpoints::ServerEnd<ScoConnectionMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// Parameters used to emulate a peer's behavior over the BR/EDR/Low Energy transport.
#[derive(Debug, Default, PartialEq)]
pub struct PeerParameters {
    /// The public BR/EDR BD_ADDR address of a peer. This field is mandatory.
    pub address: Option<fidl_fuchsia_bluetooth::Address>,
    /// When present and true, the peer will send connectable advertisements and accept connection
    /// requests. The peer will ignore connection requests if not connectable.
    pub connectable: Option<bool>,
    /// Server end of channel bound to Peer protocol.
    pub channel: Option<fidl::endpoints::ServerEnd<PeerMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct VirtualControllerCreateLoopbackDeviceRequest {
    pub uart_channel: Option<fidl::Channel>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

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

impl fidl::endpoints::ProtocolMarker for EmulatorMarker {
    type Proxy = EmulatorProxy;
    type RequestStream = EmulatorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = EmulatorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.hardware.bluetooth.Emulator";
}
impl fidl::endpoints::DiscoverableProtocolMarker for EmulatorMarker {}
pub type EmulatorPublishResult = Result<(), EmulatorError>;
pub type EmulatorAddLowEnergyPeerResult = Result<(), EmulatorPeerError>;
pub type EmulatorAddBredrPeerResult = Result<(), EmulatorPeerError>;

pub trait EmulatorProxyInterface: Send + Sync {
    type PublishResponseFut: std::future::Future<Output = Result<EmulatorPublishResult, fidl::Error>>
        + Send;
    fn r#publish(&self, payload: &EmulatorSettings) -> Self::PublishResponseFut;
    type AddLowEnergyPeerResponseFut: std::future::Future<Output = Result<EmulatorAddLowEnergyPeerResult, fidl::Error>>
        + Send;
    fn r#add_low_energy_peer(&self, payload: PeerParameters) -> Self::AddLowEnergyPeerResponseFut;
    type AddBredrPeerResponseFut: std::future::Future<Output = Result<EmulatorAddBredrPeerResult, fidl::Error>>
        + Send;
    fn r#add_bredr_peer(&self, payload: PeerParameters) -> Self::AddBredrPeerResponseFut;
    type WatchControllerParametersResponseFut: std::future::Future<Output = Result<ControllerParameters, fidl::Error>>
        + Send;
    fn r#watch_controller_parameters(&self) -> Self::WatchControllerParametersResponseFut;
    type WatchLeScanStatesResponseFut: std::future::Future<Output = Result<Vec<LeScanState>, fidl::Error>>
        + Send;
    fn r#watch_le_scan_states(&self) -> Self::WatchLeScanStatesResponseFut;
    type WatchLegacyAdvertisingStatesResponseFut: std::future::Future<Output = Result<Vec<LegacyAdvertisingState>, fidl::Error>>
        + Send;
    fn r#watch_legacy_advertising_states(&self) -> Self::WatchLegacyAdvertisingStatesResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct EmulatorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for EmulatorSynchronousProxy {
    type Proxy = EmulatorProxy;
    type Protocol = EmulatorMarker;

    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 EmulatorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <EmulatorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// Publish a bt-hci device using the provided `settings`. Each Emulator instance can only
    /// manage a single bt-hci device. Returns Emulator.`HCI_ALREADY_PUBLISHED` if the device has
    /// already been published.
    pub fn r#publish(
        &self,
        mut payload: &EmulatorSettings,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmulatorPublishResult, fidl::Error> {
        let _response = self.client.send_query::<
            EmulatorSettings,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, EmulatorError>,
        >(
            payload,
            0x5b8aeb2ece853c39,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<EmulatorMarker>("publish")?;
        Ok(_response.map(|x| x))
    }

    /// Inserts a new LE peer device to be emulated by this controller. Once registered, the state
    /// of the fake peer can be driven and observed using the `peer` handle.
    ///
    /// A reply will be sent to acknowledge the creation of the fake peer. If a peer cannot be
    /// initialized (e.g. due to a missing required field in `parameters` or for containing an
    /// address that is already emulated) the `peer` handle will be closed and an error reply will
    /// be sent.
    ///
    /// The peer will appear in advertising reports and respond to requests according to its
    /// configuration as long as the `peer` channel is open. The emulator stops emulating this peer
    /// when the channel gets closed, which makes it no longer discoverable and not respond to any
    /// requests.
    pub fn r#add_low_energy_peer(
        &self,
        mut payload: PeerParameters,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmulatorAddLowEnergyPeerResult, fidl::Error> {
        let _response = self.client.send_query::<
            PeerParameters,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, EmulatorPeerError>,
        >(
            &mut payload,
            0x4e1fb7adbebc6946,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<EmulatorMarker>("add_low_energy_peer")?;
        Ok(_response.map(|x| x))
    }

    /// Inserts a new BR/EDR peer device to be emulated by this controller. Once registered, the state
    /// of the fake peer can be driven and observed using the `peer` handle.
    ///
    /// A reply will be sent to acknowledge the creation of the fake peer. If a peer cannot be
    /// initialized (e.g. due to a missing required field in `parameters` or for containing an
    /// address that is already emulated) the `peer` handle will be closed and an error reply will
    /// be sent.
    ///
    /// The peer will appear in inquiry results and respond to requests according to its
    /// configuration as long as the `peer` channel is open. The emulator stops emulating this peer
    /// when the channel gets closed, which makes it no longer discoverable and not respond to any
    /// requests.
    pub fn r#add_bredr_peer(
        &self,
        mut payload: PeerParameters,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmulatorAddBredrPeerResult, fidl::Error> {
        let _response = self.client.send_query::<
            PeerParameters,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, EmulatorPeerError>,
        >(
            &mut payload,
            0x6d15989a0373e07,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<EmulatorMarker>("add_bredr_peer")?;
        Ok(_response.map(|x| x))
    }

    /// Hanging get pattern for the controller parameter state will not resolve until the state has
    /// changed from the last response.
    pub fn r#watch_controller_parameters(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControllerParameters, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<ControllerParameters>,
        >(
            (),
            0x6ed7a918b5800270,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<EmulatorMarker>("watch_controller_parameters")?;
        Ok(_response)
    }

    /// Returns a vector of the least to most recent states for the link layer LE scan procedure.
    /// This method returns when there has been at least one state change since the last invocation
    /// of this method by this client.
    ///
    /// Multiple calls to this method can be outstanding at a given time. All calls will resolve in
    /// a response as soon as there is a change to the scan state.
    pub fn r#watch_le_scan_states(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<LeScanState>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<EmulatorWatchLeScanStatesResponse>,
        >(
            (),
            0x10e6c845831f3b4a,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<EmulatorMarker>("watch_le_scan_states")?;
        Ok(_response.states)
    }

    /// Returns a vector of the least to most recent states for the link layer LE legacy
    /// advertising procedure. This method returns when there has been at least one state change
    /// since the last invocation of this method by this client.
    ///
    /// Multiple calls to this method can be outstanding at a given time. All calls will resolve in
    /// a response as soon as there is a change to the scan state.
    pub fn r#watch_legacy_advertising_states(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<LegacyAdvertisingState>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<EmulatorWatchLegacyAdvertisingStatesResponse>,
        >(
            (),
            0x7067acbe275d0219,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<EmulatorMarker>("watch_legacy_advertising_states")?;
        Ok(_response.states)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for EmulatorProxy {
    type Protocol = EmulatorMarker;

    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 EmulatorProxy {
    /// Create a new Proxy for fuchsia.hardware.bluetooth/Emulator.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <EmulatorMarker 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) -> EmulatorEventStream {
        EmulatorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Publish a bt-hci device using the provided `settings`. Each Emulator instance can only
    /// manage a single bt-hci device. Returns Emulator.`HCI_ALREADY_PUBLISHED` if the device has
    /// already been published.
    pub fn r#publish(
        &self,
        mut payload: &EmulatorSettings,
    ) -> fidl::client::QueryResponseFut<
        EmulatorPublishResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        EmulatorProxyInterface::r#publish(self, payload)
    }

    /// Inserts a new LE peer device to be emulated by this controller. Once registered, the state
    /// of the fake peer can be driven and observed using the `peer` handle.
    ///
    /// A reply will be sent to acknowledge the creation of the fake peer. If a peer cannot be
    /// initialized (e.g. due to a missing required field in `parameters` or for containing an
    /// address that is already emulated) the `peer` handle will be closed and an error reply will
    /// be sent.
    ///
    /// The peer will appear in advertising reports and respond to requests according to its
    /// configuration as long as the `peer` channel is open. The emulator stops emulating this peer
    /// when the channel gets closed, which makes it no longer discoverable and not respond to any
    /// requests.
    pub fn r#add_low_energy_peer(
        &self,
        mut payload: PeerParameters,
    ) -> fidl::client::QueryResponseFut<
        EmulatorAddLowEnergyPeerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        EmulatorProxyInterface::r#add_low_energy_peer(self, payload)
    }

    /// Inserts a new BR/EDR peer device to be emulated by this controller. Once registered, the state
    /// of the fake peer can be driven and observed using the `peer` handle.
    ///
    /// A reply will be sent to acknowledge the creation of the fake peer. If a peer cannot be
    /// initialized (e.g. due to a missing required field in `parameters` or for containing an
    /// address that is already emulated) the `peer` handle will be closed and an error reply will
    /// be sent.
    ///
    /// The peer will appear in inquiry results and respond to requests according to its
    /// configuration as long as the `peer` channel is open. The emulator stops emulating this peer
    /// when the channel gets closed, which makes it no longer discoverable and not respond to any
    /// requests.
    pub fn r#add_bredr_peer(
        &self,
        mut payload: PeerParameters,
    ) -> fidl::client::QueryResponseFut<
        EmulatorAddBredrPeerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        EmulatorProxyInterface::r#add_bredr_peer(self, payload)
    }

    /// Hanging get pattern for the controller parameter state will not resolve until the state has
    /// changed from the last response.
    pub fn r#watch_controller_parameters(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ControllerParameters,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        EmulatorProxyInterface::r#watch_controller_parameters(self)
    }

    /// Returns a vector of the least to most recent states for the link layer LE scan procedure.
    /// This method returns when there has been at least one state change since the last invocation
    /// of this method by this client.
    ///
    /// Multiple calls to this method can be outstanding at a given time. All calls will resolve in
    /// a response as soon as there is a change to the scan state.
    pub fn r#watch_le_scan_states(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<LeScanState>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        EmulatorProxyInterface::r#watch_le_scan_states(self)
    }

    /// Returns a vector of the least to most recent states for the link layer LE legacy
    /// advertising procedure. This method returns when there has been at least one state change
    /// since the last invocation of this method by this client.
    ///
    /// Multiple calls to this method can be outstanding at a given time. All calls will resolve in
    /// a response as soon as there is a change to the scan state.
    pub fn r#watch_legacy_advertising_states(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<LegacyAdvertisingState>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        EmulatorProxyInterface::r#watch_legacy_advertising_states(self)
    }
}

impl EmulatorProxyInterface for EmulatorProxy {
    type PublishResponseFut = fidl::client::QueryResponseFut<
        EmulatorPublishResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#publish(&self, mut payload: &EmulatorSettings) -> Self::PublishResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmulatorPublishResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, EmulatorError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5b8aeb2ece853c39,
            >(_buf?)?
            .into_result::<EmulatorMarker>("publish")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<EmulatorSettings, EmulatorPublishResult>(
            payload,
            0x5b8aeb2ece853c39,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type AddLowEnergyPeerResponseFut = fidl::client::QueryResponseFut<
        EmulatorAddLowEnergyPeerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_low_energy_peer(
        &self,
        mut payload: PeerParameters,
    ) -> Self::AddLowEnergyPeerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmulatorAddLowEnergyPeerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, EmulatorPeerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4e1fb7adbebc6946,
            >(_buf?)?
            .into_result::<EmulatorMarker>("add_low_energy_peer")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<PeerParameters, EmulatorAddLowEnergyPeerResult>(
            &mut payload,
            0x4e1fb7adbebc6946,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type AddBredrPeerResponseFut = fidl::client::QueryResponseFut<
        EmulatorAddBredrPeerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_bredr_peer(&self, mut payload: PeerParameters) -> Self::AddBredrPeerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmulatorAddBredrPeerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, EmulatorPeerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6d15989a0373e07,
            >(_buf?)?
            .into_result::<EmulatorMarker>("add_bredr_peer")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<PeerParameters, EmulatorAddBredrPeerResult>(
            &mut payload,
            0x6d15989a0373e07,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type WatchControllerParametersResponseFut = fidl::client::QueryResponseFut<
        ControllerParameters,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_controller_parameters(&self) -> Self::WatchControllerParametersResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControllerParameters, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<ControllerParameters>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ed7a918b5800270,
            >(_buf?)?
            .into_result::<EmulatorMarker>("watch_controller_parameters")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ControllerParameters>(
            (),
            0x6ed7a918b5800270,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type WatchLeScanStatesResponseFut = fidl::client::QueryResponseFut<
        Vec<LeScanState>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_le_scan_states(&self) -> Self::WatchLeScanStatesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<LeScanState>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<EmulatorWatchLeScanStatesResponse>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x10e6c845831f3b4a,
            >(_buf?)?
            .into_result::<EmulatorMarker>("watch_le_scan_states")?;
            Ok(_response.states)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<LeScanState>>(
            (),
            0x10e6c845831f3b4a,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type WatchLegacyAdvertisingStatesResponseFut = fidl::client::QueryResponseFut<
        Vec<LegacyAdvertisingState>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_legacy_advertising_states(&self) -> Self::WatchLegacyAdvertisingStatesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<LegacyAdvertisingState>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<EmulatorWatchLegacyAdvertisingStatesResponse>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7067acbe275d0219,
            >(_buf?)?
            .into_result::<EmulatorMarker>("watch_legacy_advertising_states")?;
            Ok(_response.states)
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<LegacyAdvertisingState>>(
                (),
                0x7067acbe275d0219,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.bluetooth/Emulator.
pub struct EmulatorRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for EmulatorRequestStream {
    type Protocol = EmulatorMarker;
    type ControlHandle = EmulatorControlHandle;

    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 {
        EmulatorControlHandle { 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 EmulatorRequestStream {
    type Item = Result<EmulatorRequest, 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 EmulatorRequestStream 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 {
                    0x5b8aeb2ece853c39 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            EmulatorSettings,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EmulatorSettings>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = EmulatorControlHandle { inner: this.inner.clone() };
                        Ok(EmulatorRequest::Publish {
                            payload: req,
                            responder: EmulatorPublishResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4e1fb7adbebc6946 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PeerParameters,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeerParameters>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = EmulatorControlHandle { inner: this.inner.clone() };
                        Ok(EmulatorRequest::AddLowEnergyPeer {
                            payload: req,
                            responder: EmulatorAddLowEnergyPeerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6d15989a0373e07 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PeerParameters,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeerParameters>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = EmulatorControlHandle { inner: this.inner.clone() };
                        Ok(EmulatorRequest::AddBredrPeer {
                            payload: req,
                            responder: EmulatorAddBredrPeerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6ed7a918b5800270 => {
                        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 = EmulatorControlHandle { inner: this.inner.clone() };
                        Ok(EmulatorRequest::WatchControllerParameters {
                            responder: EmulatorWatchControllerParametersResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x10e6c845831f3b4a => {
                        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 = EmulatorControlHandle { inner: this.inner.clone() };
                        Ok(EmulatorRequest::WatchLeScanStates {
                            responder: EmulatorWatchLeScanStatesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7067acbe275d0219 => {
                        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 = EmulatorControlHandle { inner: this.inner.clone() };
                        Ok(EmulatorRequest::WatchLegacyAdvertisingStates {
                            responder: EmulatorWatchLegacyAdvertisingStatesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(EmulatorRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: EmulatorControlHandle { 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(EmulatorRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: EmulatorControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <EmulatorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol used to emulate a Bluetooth controller that supports the standard Bluetooth HCI.
/// Represents the bt-emulator device protocol. A bt-emulator device is used for configuring and
/// publishing fake bt-hci devices.
#[derive(Debug)]
pub enum EmulatorRequest {
    /// Publish a bt-hci device using the provided `settings`. Each Emulator instance can only
    /// manage a single bt-hci device. Returns Emulator.`HCI_ALREADY_PUBLISHED` if the device has
    /// already been published.
    Publish { payload: EmulatorSettings, responder: EmulatorPublishResponder },
    /// Inserts a new LE peer device to be emulated by this controller. Once registered, the state
    /// of the fake peer can be driven and observed using the `peer` handle.
    ///
    /// A reply will be sent to acknowledge the creation of the fake peer. If a peer cannot be
    /// initialized (e.g. due to a missing required field in `parameters` or for containing an
    /// address that is already emulated) the `peer` handle will be closed and an error reply will
    /// be sent.
    ///
    /// The peer will appear in advertising reports and respond to requests according to its
    /// configuration as long as the `peer` channel is open. The emulator stops emulating this peer
    /// when the channel gets closed, which makes it no longer discoverable and not respond to any
    /// requests.
    AddLowEnergyPeer { payload: PeerParameters, responder: EmulatorAddLowEnergyPeerResponder },
    /// Inserts a new BR/EDR peer device to be emulated by this controller. Once registered, the state
    /// of the fake peer can be driven and observed using the `peer` handle.
    ///
    /// A reply will be sent to acknowledge the creation of the fake peer. If a peer cannot be
    /// initialized (e.g. due to a missing required field in `parameters` or for containing an
    /// address that is already emulated) the `peer` handle will be closed and an error reply will
    /// be sent.
    ///
    /// The peer will appear in inquiry results and respond to requests according to its
    /// configuration as long as the `peer` channel is open. The emulator stops emulating this peer
    /// when the channel gets closed, which makes it no longer discoverable and not respond to any
    /// requests.
    AddBredrPeer { payload: PeerParameters, responder: EmulatorAddBredrPeerResponder },
    /// Hanging get pattern for the controller parameter state will not resolve until the state has
    /// changed from the last response.
    WatchControllerParameters { responder: EmulatorWatchControllerParametersResponder },
    /// Returns a vector of the least to most recent states for the link layer LE scan procedure.
    /// This method returns when there has been at least one state change since the last invocation
    /// of this method by this client.
    ///
    /// Multiple calls to this method can be outstanding at a given time. All calls will resolve in
    /// a response as soon as there is a change to the scan state.
    WatchLeScanStates { responder: EmulatorWatchLeScanStatesResponder },
    /// Returns a vector of the least to most recent states for the link layer LE legacy
    /// advertising procedure. This method returns when there has been at least one state change
    /// since the last invocation of this method by this client.
    ///
    /// Multiple calls to this method can be outstanding at a given time. All calls will resolve in
    /// a response as soon as there is a change to the scan state.
    WatchLegacyAdvertisingStates { responder: EmulatorWatchLegacyAdvertisingStatesResponder },
    /// 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: EmulatorControlHandle,
        method_type: fidl::MethodType,
    },
}

impl EmulatorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_publish(self) -> Option<(EmulatorSettings, EmulatorPublishResponder)> {
        if let EmulatorRequest::Publish { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_low_energy_peer(
        self,
    ) -> Option<(PeerParameters, EmulatorAddLowEnergyPeerResponder)> {
        if let EmulatorRequest::AddLowEnergyPeer { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_bredr_peer(self) -> Option<(PeerParameters, EmulatorAddBredrPeerResponder)> {
        if let EmulatorRequest::AddBredrPeer { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_controller_parameters(
        self,
    ) -> Option<(EmulatorWatchControllerParametersResponder)> {
        if let EmulatorRequest::WatchControllerParameters { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_le_scan_states(self) -> Option<(EmulatorWatchLeScanStatesResponder)> {
        if let EmulatorRequest::WatchLeScanStates { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_legacy_advertising_states(
        self,
    ) -> Option<(EmulatorWatchLegacyAdvertisingStatesResponder)> {
        if let EmulatorRequest::WatchLegacyAdvertisingStates { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            EmulatorRequest::Publish { .. } => "publish",
            EmulatorRequest::AddLowEnergyPeer { .. } => "add_low_energy_peer",
            EmulatorRequest::AddBredrPeer { .. } => "add_bredr_peer",
            EmulatorRequest::WatchControllerParameters { .. } => "watch_controller_parameters",
            EmulatorRequest::WatchLeScanStates { .. } => "watch_le_scan_states",
            EmulatorRequest::WatchLegacyAdvertisingStates { .. } => {
                "watch_legacy_advertising_states"
            }
            EmulatorRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            EmulatorRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

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

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

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

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

impl EmulatorControlHandle {}

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

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

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

    fn send_raw(&self, mut result: Result<(), EmulatorError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            EmulatorError,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x5b8aeb2ece853c39,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<(), EmulatorPeerError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            EmulatorPeerError,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x4e1fb7adbebc6946,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<(), EmulatorPeerError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            EmulatorPeerError,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x6d15989a0373e07,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(&self, mut payload: &ControllerParameters) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<ControllerParameters>>(
            fidl::encoding::Flexible::new(payload),
            self.tx_id,
            0x6ed7a918b5800270,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(&self, mut states: &[LeScanState]) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleType<EmulatorWatchLeScanStatesResponse>>(
                fidl::encoding::Flexible::new((states,)),
                self.tx_id,
                0x10e6c845831f3b4a,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

    fn send_raw(&self, mut states: &[LegacyAdvertisingState]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<
            EmulatorWatchLegacyAdvertisingStatesResponse,
        >>(
            fidl::encoding::Flexible::new((states,)),
            self.tx_id,
            0x7067acbe275d0219,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for HciMarker {
    type Proxy = HciProxy;
    type RequestStream = HciRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = HciSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Hci";
}
pub type HciOpenCommandChannelResult = Result<(), i32>;
pub type HciOpenAclDataChannelResult = Result<(), i32>;
pub type HciOpenScoDataChannelResult = Result<(), i32>;
pub type HciConfigureScoResult = Result<(), i32>;
pub type HciResetScoResult = Result<(), i32>;
pub type HciOpenIsoDataChannelResult = Result<(), i32>;
pub type HciOpenSnoopChannelResult = Result<(), i32>;

pub trait HciProxyInterface: Send + Sync {
    type OpenCommandChannelResponseFut: std::future::Future<Output = Result<HciOpenCommandChannelResult, fidl::Error>>
        + Send;
    fn r#open_command_channel(&self, channel: fidl::Channel)
    -> Self::OpenCommandChannelResponseFut;
    type OpenAclDataChannelResponseFut: std::future::Future<Output = Result<HciOpenAclDataChannelResult, fidl::Error>>
        + Send;
    fn r#open_acl_data_channel(
        &self,
        channel: fidl::Channel,
    ) -> Self::OpenAclDataChannelResponseFut;
    type OpenScoDataChannelResponseFut: std::future::Future<Output = Result<HciOpenScoDataChannelResult, fidl::Error>>
        + Send;
    fn r#open_sco_data_channel(
        &self,
        channel: fidl::Channel,
    ) -> Self::OpenScoDataChannelResponseFut;
    type ConfigureScoResponseFut: std::future::Future<Output = Result<HciConfigureScoResult, fidl::Error>>
        + Send;
    fn r#configure_sco(
        &self,
        coding_format: ScoCodingFormat,
        encoding: ScoEncoding,
        sample_rate: ScoSampleRate,
    ) -> Self::ConfigureScoResponseFut;
    type ResetScoResponseFut: std::future::Future<Output = Result<HciResetScoResult, fidl::Error>>
        + Send;
    fn r#reset_sco(&self) -> Self::ResetScoResponseFut;
    type OpenIsoDataChannelResponseFut: std::future::Future<Output = Result<HciOpenIsoDataChannelResult, fidl::Error>>
        + Send;
    fn r#open_iso_data_channel(
        &self,
        channel: fidl::Channel,
    ) -> Self::OpenIsoDataChannelResponseFut;
    type OpenSnoopChannelResponseFut: std::future::Future<Output = Result<HciOpenSnoopChannelResult, fidl::Error>>
        + Send;
    fn r#open_snoop_channel(&self, channel: fidl::Channel) -> Self::OpenSnoopChannelResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct HciSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for HciSynchronousProxy {
    type Proxy = HciProxy;
    type Protocol = HciMarker;

    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 HciSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <HciMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// Open the two-way HCI command channel for sending HCI commands and
    /// receiving event packets.  Returns ZX_ERR_ALREADY_BOUND if the channel
    /// is already open.
    pub fn r#open_command_channel(
        &self,
        mut channel: fidl::Channel,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HciOpenCommandChannelResult, fidl::Error> {
        let _response = self.client.send_query::<
            HciOpenCommandChannelRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (channel,),
            0x2510b52ea3a51ce0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<HciMarker>("open_command_channel")?;
        Ok(_response.map(|x| x))
    }

    /// Open the two-way HCI ACL data channel.
    /// Returns ZX_ERR_ALREADY_BOUND if the channel is already open.
    pub fn r#open_acl_data_channel(
        &self,
        mut channel: fidl::Channel,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HciOpenAclDataChannelResult, fidl::Error> {
        let _response = self.client.send_query::<
            HciOpenAclDataChannelRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (channel,),
            0x210c3dd69156385a,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<HciMarker>("open_acl_data_channel")?;
        Ok(_response.map(|x| x))
    }

    /// Opens a SCO channel on the provided handle. The zircon channel is
    /// closed in the event of an error opening the hci channel or if the hci
    /// channel is already associated with a handle to another zircon channel.
    /// Returns ZX_ERR_NOT_SUPPORTED if SCO is not supported by the current vendor or transport
    /// driver.
    /// Returns ZX_ERR_ALREADY_BOUND if the channel is already open.
    pub fn r#open_sco_data_channel(
        &self,
        mut channel: fidl::Channel,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HciOpenScoDataChannelResult, fidl::Error> {
        let _response = self.client.send_query::<
            HciOpenScoDataChannelRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (channel,),
            0x5bcb0bf2cbf35bdf,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<HciMarker>("open_sco_data_channel")?;
        Ok(_response.map(|x| x))
    }

    /// Configure the HCI for a SCO connection with the indicated parameters.
    /// This must be called before sending/receiving data on the SCO channel.
    /// Returns ZX_ERR_NOT_SUPPORTED if SCO is not supported by the current vendor or transport
    /// driver.
    pub fn r#configure_sco(
        &self,
        mut coding_format: ScoCodingFormat,
        mut encoding: ScoEncoding,
        mut sample_rate: ScoSampleRate,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HciConfigureScoResult, fidl::Error> {
        let _response = self.client.send_query::<
            HciConfigureScoRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (coding_format, encoding, sample_rate,),
            0x499ec7edfd65fad7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<HciMarker>("configure_sco")?;
        Ok(_response.map(|x| x))
    }

    /// Releases resources held by an active SCO connection. Must be called
    /// when a SCO connection is closed.
    /// Returns ZX_ERR_NOT_SUPPORTED if SCO is not supported by the current vendor or transport
    /// driver.
    pub fn r#reset_sco(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HciResetScoResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x6ee56dcb2ce23fcb,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<HciMarker>("reset_sco")?;
        Ok(_response.map(|x| x))
    }

    /// Opens a channel on the provided handle for sending and receiving isochronous data packets.
    /// The zircon channel is closed in the event of an error opening the hci channel or if the hci
    /// channel is already associated with a handle to another zircon channel.
    /// Returns ZX_ERR_NOT_SUPPORTED if ISO is not supported by the current vendor or transport
    /// driver.
    /// Returns ZX_ERR_ALREADY_BOUND if the channel is already open.
    pub fn r#open_iso_data_channel(
        &self,
        mut channel: fidl::Channel,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HciOpenIsoDataChannelResult, fidl::Error> {
        let _response = self.client.send_query::<
            HciOpenIsoDataChannelRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (channel,),
            0x9adfa1d466cefd4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<HciMarker>("open_iso_data_channel")?;
        Ok(_response.map(|x| x))
    }

    /// Open an output-only channel for monitoring HCI traffic.
    /// The format of each message is: [1-octet flags] [n-octet payload]
    /// The flags octet is a bitfield with the following values defined:
    ///  - 0x00: The payload represents a command packet sent from the host to the
    ///          controller.
    ///  - 0x01: The payload represents an event packet sent by the controller.
    /// Returns ZX_ERR_ALREADY_BOUND if the channel is already open.
    pub fn r#open_snoop_channel(
        &self,
        mut channel: fidl::Channel,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HciOpenSnoopChannelResult, fidl::Error> {
        let _response = self.client.send_query::<
            HciOpenSnoopChannelRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (channel,),
            0xd31c6d5cbc4e136,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<HciMarker>("open_snoop_channel")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for HciProxy {
    type Protocol = HciMarker;

    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 HciProxy {
    /// Create a new Proxy for fuchsia.hardware.bluetooth/Hci.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <HciMarker 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) -> HciEventStream {
        HciEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Open the two-way HCI command channel for sending HCI commands and
    /// receiving event packets.  Returns ZX_ERR_ALREADY_BOUND if the channel
    /// is already open.
    pub fn r#open_command_channel(
        &self,
        mut channel: fidl::Channel,
    ) -> fidl::client::QueryResponseFut<
        HciOpenCommandChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        HciProxyInterface::r#open_command_channel(self, channel)
    }

    /// Open the two-way HCI ACL data channel.
    /// Returns ZX_ERR_ALREADY_BOUND if the channel is already open.
    pub fn r#open_acl_data_channel(
        &self,
        mut channel: fidl::Channel,
    ) -> fidl::client::QueryResponseFut<
        HciOpenAclDataChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        HciProxyInterface::r#open_acl_data_channel(self, channel)
    }

    /// Opens a SCO channel on the provided handle. The zircon channel is
    /// closed in the event of an error opening the hci channel or if the hci
    /// channel is already associated with a handle to another zircon channel.
    /// Returns ZX_ERR_NOT_SUPPORTED if SCO is not supported by the current vendor or transport
    /// driver.
    /// Returns ZX_ERR_ALREADY_BOUND if the channel is already open.
    pub fn r#open_sco_data_channel(
        &self,
        mut channel: fidl::Channel,
    ) -> fidl::client::QueryResponseFut<
        HciOpenScoDataChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        HciProxyInterface::r#open_sco_data_channel(self, channel)
    }

    /// Configure the HCI for a SCO connection with the indicated parameters.
    /// This must be called before sending/receiving data on the SCO channel.
    /// Returns ZX_ERR_NOT_SUPPORTED if SCO is not supported by the current vendor or transport
    /// driver.
    pub fn r#configure_sco(
        &self,
        mut coding_format: ScoCodingFormat,
        mut encoding: ScoEncoding,
        mut sample_rate: ScoSampleRate,
    ) -> fidl::client::QueryResponseFut<
        HciConfigureScoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        HciProxyInterface::r#configure_sco(self, coding_format, encoding, sample_rate)
    }

    /// Releases resources held by an active SCO connection. Must be called
    /// when a SCO connection is closed.
    /// Returns ZX_ERR_NOT_SUPPORTED if SCO is not supported by the current vendor or transport
    /// driver.
    pub fn r#reset_sco(
        &self,
    ) -> fidl::client::QueryResponseFut<
        HciResetScoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        HciProxyInterface::r#reset_sco(self)
    }

    /// Opens a channel on the provided handle for sending and receiving isochronous data packets.
    /// The zircon channel is closed in the event of an error opening the hci channel or if the hci
    /// channel is already associated with a handle to another zircon channel.
    /// Returns ZX_ERR_NOT_SUPPORTED if ISO is not supported by the current vendor or transport
    /// driver.
    /// Returns ZX_ERR_ALREADY_BOUND if the channel is already open.
    pub fn r#open_iso_data_channel(
        &self,
        mut channel: fidl::Channel,
    ) -> fidl::client::QueryResponseFut<
        HciOpenIsoDataChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        HciProxyInterface::r#open_iso_data_channel(self, channel)
    }

    /// Open an output-only channel for monitoring HCI traffic.
    /// The format of each message is: [1-octet flags] [n-octet payload]
    /// The flags octet is a bitfield with the following values defined:
    ///  - 0x00: The payload represents a command packet sent from the host to the
    ///          controller.
    ///  - 0x01: The payload represents an event packet sent by the controller.
    /// Returns ZX_ERR_ALREADY_BOUND if the channel is already open.
    pub fn r#open_snoop_channel(
        &self,
        mut channel: fidl::Channel,
    ) -> fidl::client::QueryResponseFut<
        HciOpenSnoopChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        HciProxyInterface::r#open_snoop_channel(self, channel)
    }
}

impl HciProxyInterface for HciProxy {
    type OpenCommandChannelResponseFut = fidl::client::QueryResponseFut<
        HciOpenCommandChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_command_channel(
        &self,
        mut channel: fidl::Channel,
    ) -> Self::OpenCommandChannelResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HciOpenCommandChannelResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2510b52ea3a51ce0,
            >(_buf?)?
            .into_result::<HciMarker>("open_command_channel")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<HciOpenCommandChannelRequest, HciOpenCommandChannelResult>(
                (channel,),
                0x2510b52ea3a51ce0,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type OpenAclDataChannelResponseFut = fidl::client::QueryResponseFut<
        HciOpenAclDataChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_acl_data_channel(
        &self,
        mut channel: fidl::Channel,
    ) -> Self::OpenAclDataChannelResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HciOpenAclDataChannelResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x210c3dd69156385a,
            >(_buf?)?
            .into_result::<HciMarker>("open_acl_data_channel")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<HciOpenAclDataChannelRequest, HciOpenAclDataChannelResult>(
                (channel,),
                0x210c3dd69156385a,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type OpenScoDataChannelResponseFut = fidl::client::QueryResponseFut<
        HciOpenScoDataChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_sco_data_channel(
        &self,
        mut channel: fidl::Channel,
    ) -> Self::OpenScoDataChannelResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HciOpenScoDataChannelResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5bcb0bf2cbf35bdf,
            >(_buf?)?
            .into_result::<HciMarker>("open_sco_data_channel")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<HciOpenScoDataChannelRequest, HciOpenScoDataChannelResult>(
                (channel,),
                0x5bcb0bf2cbf35bdf,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type ConfigureScoResponseFut = fidl::client::QueryResponseFut<
        HciConfigureScoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#configure_sco(
        &self,
        mut coding_format: ScoCodingFormat,
        mut encoding: ScoEncoding,
        mut sample_rate: ScoSampleRate,
    ) -> Self::ConfigureScoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HciConfigureScoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x499ec7edfd65fad7,
            >(_buf?)?
            .into_result::<HciMarker>("configure_sco")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<HciConfigureScoRequest, HciConfigureScoResult>(
            (coding_format, encoding, sample_rate),
            0x499ec7edfd65fad7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ResetScoResponseFut = fidl::client::QueryResponseFut<
        HciResetScoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#reset_sco(&self) -> Self::ResetScoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HciResetScoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ee56dcb2ce23fcb,
            >(_buf?)?
            .into_result::<HciMarker>("reset_sco")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, HciResetScoResult>(
            (),
            0x6ee56dcb2ce23fcb,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type OpenIsoDataChannelResponseFut = fidl::client::QueryResponseFut<
        HciOpenIsoDataChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_iso_data_channel(
        &self,
        mut channel: fidl::Channel,
    ) -> Self::OpenIsoDataChannelResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HciOpenIsoDataChannelResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x9adfa1d466cefd4,
            >(_buf?)?
            .into_result::<HciMarker>("open_iso_data_channel")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<HciOpenIsoDataChannelRequest, HciOpenIsoDataChannelResult>(
                (channel,),
                0x9adfa1d466cefd4,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type OpenSnoopChannelResponseFut = fidl::client::QueryResponseFut<
        HciOpenSnoopChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_snoop_channel(
        &self,
        mut channel: fidl::Channel,
    ) -> Self::OpenSnoopChannelResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<HciOpenSnoopChannelResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xd31c6d5cbc4e136,
            >(_buf?)?
            .into_result::<HciMarker>("open_snoop_channel")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<HciOpenSnoopChannelRequest, HciOpenSnoopChannelResult>(
            (channel,),
            0xd31c6d5cbc4e136,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.bluetooth/Hci.
pub struct HciRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for HciRequestStream {
    type Protocol = HciMarker;
    type ControlHandle = HciControlHandle;

    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 {
        HciControlHandle { 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 HciRequestStream {
    type Item = Result<HciRequest, 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 HciRequestStream 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 {
                    0x2510b52ea3a51ce0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            HciOpenCommandChannelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HciOpenCommandChannelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = HciControlHandle { inner: this.inner.clone() };
                        Ok(HciRequest::OpenCommandChannel {
                            channel: req.channel,

                            responder: HciOpenCommandChannelResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x210c3dd69156385a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            HciOpenAclDataChannelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HciOpenAclDataChannelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = HciControlHandle { inner: this.inner.clone() };
                        Ok(HciRequest::OpenAclDataChannel {
                            channel: req.channel,

                            responder: HciOpenAclDataChannelResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5bcb0bf2cbf35bdf => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            HciOpenScoDataChannelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HciOpenScoDataChannelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = HciControlHandle { inner: this.inner.clone() };
                        Ok(HciRequest::OpenScoDataChannel {
                            channel: req.channel,

                            responder: HciOpenScoDataChannelResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x499ec7edfd65fad7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            HciConfigureScoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HciConfigureScoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = HciControlHandle { inner: this.inner.clone() };
                        Ok(HciRequest::ConfigureSco {
                            coding_format: req.coding_format,
                            encoding: req.encoding,
                            sample_rate: req.sample_rate,

                            responder: HciConfigureScoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6ee56dcb2ce23fcb => {
                        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 = HciControlHandle { inner: this.inner.clone() };
                        Ok(HciRequest::ResetSco {
                            responder: HciResetScoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x9adfa1d466cefd4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            HciOpenIsoDataChannelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HciOpenIsoDataChannelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = HciControlHandle { inner: this.inner.clone() };
                        Ok(HciRequest::OpenIsoDataChannel {
                            channel: req.channel,

                            responder: HciOpenIsoDataChannelResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xd31c6d5cbc4e136 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            HciOpenSnoopChannelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HciOpenSnoopChannelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = HciControlHandle { inner: this.inner.clone() };
                        Ok(HciRequest::OpenSnoopChannel {
                            channel: req.channel,

                            responder: HciOpenSnoopChannelResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(HciRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: HciControlHandle { 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(HciRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: HciControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name: <HciMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum HciRequest {
    /// Open the two-way HCI command channel for sending HCI commands and
    /// receiving event packets.  Returns ZX_ERR_ALREADY_BOUND if the channel
    /// is already open.
    OpenCommandChannel { channel: fidl::Channel, responder: HciOpenCommandChannelResponder },
    /// Open the two-way HCI ACL data channel.
    /// Returns ZX_ERR_ALREADY_BOUND if the channel is already open.
    OpenAclDataChannel { channel: fidl::Channel, responder: HciOpenAclDataChannelResponder },
    /// Opens a SCO channel on the provided handle. The zircon channel is
    /// closed in the event of an error opening the hci channel or if the hci
    /// channel is already associated with a handle to another zircon channel.
    /// Returns ZX_ERR_NOT_SUPPORTED if SCO is not supported by the current vendor or transport
    /// driver.
    /// Returns ZX_ERR_ALREADY_BOUND if the channel is already open.
    OpenScoDataChannel { channel: fidl::Channel, responder: HciOpenScoDataChannelResponder },
    /// Configure the HCI for a SCO connection with the indicated parameters.
    /// This must be called before sending/receiving data on the SCO channel.
    /// Returns ZX_ERR_NOT_SUPPORTED if SCO is not supported by the current vendor or transport
    /// driver.
    ConfigureSco {
        coding_format: ScoCodingFormat,
        encoding: ScoEncoding,
        sample_rate: ScoSampleRate,
        responder: HciConfigureScoResponder,
    },
    /// Releases resources held by an active SCO connection. Must be called
    /// when a SCO connection is closed.
    /// Returns ZX_ERR_NOT_SUPPORTED if SCO is not supported by the current vendor or transport
    /// driver.
    ResetSco { responder: HciResetScoResponder },
    /// Opens a channel on the provided handle for sending and receiving isochronous data packets.
    /// The zircon channel is closed in the event of an error opening the hci channel or if the hci
    /// channel is already associated with a handle to another zircon channel.
    /// Returns ZX_ERR_NOT_SUPPORTED if ISO is not supported by the current vendor or transport
    /// driver.
    /// Returns ZX_ERR_ALREADY_BOUND if the channel is already open.
    OpenIsoDataChannel { channel: fidl::Channel, responder: HciOpenIsoDataChannelResponder },
    /// Open an output-only channel for monitoring HCI traffic.
    /// The format of each message is: [1-octet flags] [n-octet payload]
    /// The flags octet is a bitfield with the following values defined:
    ///  - 0x00: The payload represents a command packet sent from the host to the
    ///          controller.
    ///  - 0x01: The payload represents an event packet sent by the controller.
    /// Returns ZX_ERR_ALREADY_BOUND if the channel is already open.
    OpenSnoopChannel { channel: fidl::Channel, responder: HciOpenSnoopChannelResponder },
    /// 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: HciControlHandle,
        method_type: fidl::MethodType,
    },
}

impl HciRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_open_command_channel(
        self,
    ) -> Option<(fidl::Channel, HciOpenCommandChannelResponder)> {
        if let HciRequest::OpenCommandChannel { channel, responder } = self {
            Some((channel, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_acl_data_channel(
        self,
    ) -> Option<(fidl::Channel, HciOpenAclDataChannelResponder)> {
        if let HciRequest::OpenAclDataChannel { channel, responder } = self {
            Some((channel, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_sco_data_channel(
        self,
    ) -> Option<(fidl::Channel, HciOpenScoDataChannelResponder)> {
        if let HciRequest::OpenScoDataChannel { channel, responder } = self {
            Some((channel, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_configure_sco(
        self,
    ) -> Option<(ScoCodingFormat, ScoEncoding, ScoSampleRate, HciConfigureScoResponder)> {
        if let HciRequest::ConfigureSco { coding_format, encoding, sample_rate, responder } = self {
            Some((coding_format, encoding, sample_rate, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reset_sco(self) -> Option<(HciResetScoResponder)> {
        if let HciRequest::ResetSco { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_iso_data_channel(
        self,
    ) -> Option<(fidl::Channel, HciOpenIsoDataChannelResponder)> {
        if let HciRequest::OpenIsoDataChannel { channel, responder } = self {
            Some((channel, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_snoop_channel(self) -> Option<(fidl::Channel, HciOpenSnoopChannelResponder)> {
        if let HciRequest::OpenSnoopChannel { channel, responder } = self {
            Some((channel, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            HciRequest::OpenCommandChannel { .. } => "open_command_channel",
            HciRequest::OpenAclDataChannel { .. } => "open_acl_data_channel",
            HciRequest::OpenScoDataChannel { .. } => "open_sco_data_channel",
            HciRequest::ConfigureSco { .. } => "configure_sco",
            HciRequest::ResetSco { .. } => "reset_sco",
            HciRequest::OpenIsoDataChannel { .. } => "open_iso_data_channel",
            HciRequest::OpenSnoopChannel { .. } => "open_snoop_channel",
            HciRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            HciRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

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

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

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

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

impl HciControlHandle {}

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

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

    fn control_handle(&self) -> &HciControlHandle {
        &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 HciOpenCommandChannelResponder {
    /// 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::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x2510b52ea3a51ce0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &HciControlHandle {
        &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 HciOpenAclDataChannelResponder {
    /// 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::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x210c3dd69156385a,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &HciControlHandle {
        &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 HciOpenScoDataChannelResponder {
    /// 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::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x5bcb0bf2cbf35bdf,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &HciControlHandle {
        &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 HciConfigureScoResponder {
    /// 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::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x499ec7edfd65fad7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &HciControlHandle {
        &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 HciResetScoResponder {
    /// 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::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x6ee56dcb2ce23fcb,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &HciControlHandle {
        &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 HciOpenIsoDataChannelResponder {
    /// 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::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x9adfa1d466cefd4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &HciControlHandle {
        &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 HciOpenSnoopChannelResponder {
    /// 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::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0xd31c6d5cbc4e136,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for HciTransportMarker {
    type Proxy = HciTransportProxy;
    type RequestStream = HciTransportRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = HciTransportSynchronousProxy;

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

pub trait HciTransportProxyInterface: Send + Sync {
    type Send_ResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#send_(&self, payload: &SentPacket) -> Self::Send_ResponseFut;
    fn r#ack_receive(&self) -> Result<(), fidl::Error>;
    fn r#configure_sco(&self, payload: HciTransportConfigureScoRequest) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct HciTransportSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for HciTransportSynchronousProxy {
    type Proxy = HciTransportProxy;
    type Protocol = HciTransportMarker;

    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 HciTransportSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <HciTransportMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// More than one Send can be pending simultaneously.
    /// Prefer to limit the number of pending calls to avoid overflow.
    /// A maximum of 10 pending calls is suggested.
    /// If an event or SCO packet is received by the server, the server should close the protocol.
    pub fn r#send_(
        &self,
        mut payload: &SentPacket,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<SentPacket, fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
                payload,
                0x4793b5e66fd79e0b,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                ___deadline,
            )?
            .into_result::<HciTransportMarker>("send_")?;
        Ok(_response)
    }

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

    /// Establish a SCO connection. Only 1 SCO connection can be configured at a time.
    pub fn r#configure_sco(
        &self,
        mut payload: HciTransportConfigureScoRequest,
    ) -> Result<(), fidl::Error> {
        self.client.send::<HciTransportConfigureScoRequest>(
            &mut payload,
            0x4298072d0498b612,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for HciTransportProxy {
    type Protocol = HciTransportMarker;

    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 HciTransportProxy {
    /// Create a new Proxy for fuchsia.hardware.bluetooth/HciTransport.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <HciTransportMarker 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) -> HciTransportEventStream {
        HciTransportEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// More than one Send can be pending simultaneously.
    /// Prefer to limit the number of pending calls to avoid overflow.
    /// A maximum of 10 pending calls is suggested.
    /// If an event or SCO packet is received by the server, the server should close the protocol.
    pub fn r#send_(
        &self,
        mut payload: &SentPacket,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        HciTransportProxyInterface::r#send_(self, payload)
    }

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

    /// Establish a SCO connection. Only 1 SCO connection can be configured at a time.
    pub fn r#configure_sco(
        &self,
        mut payload: HciTransportConfigureScoRequest,
    ) -> Result<(), fidl::Error> {
        HciTransportProxyInterface::r#configure_sco(self, payload)
    }
}

impl HciTransportProxyInterface for HciTransportProxy {
    type Send_ResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#send_(&self, mut payload: &SentPacket) -> Self::Send_ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4793b5e66fd79e0b,
            >(_buf?)?
            .into_result::<HciTransportMarker>("send_")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<SentPacket, ()>(
            payload,
            0x4793b5e66fd79e0b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

    fn r#configure_sco(
        &self,
        mut payload: HciTransportConfigureScoRequest,
    ) -> Result<(), fidl::Error> {
        self.client.send::<HciTransportConfigureScoRequest>(
            &mut payload,
            0x4298072d0498b612,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

impl HciTransportEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_receive(self) -> Option<ReceivedPacket> {
        if let HciTransportEvent::OnReceive { payload } = self { Some((payload)) } else { None }
    }

    /// Decodes a message buffer as a [`HciTransportEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<HciTransportEvent, 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 {
            0xcb102e573e5049c => {
                let mut out =
                    fidl::new_empty!(ReceivedPacket, fidl::encoding::DefaultFuchsiaResourceDialect);
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ReceivedPacket>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((HciTransportEvent::OnReceive { payload: out }))
            }
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(HciTransportEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <HciTransportMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.hardware.bluetooth/HciTransport.
pub struct HciTransportRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for HciTransportRequestStream {
    type Protocol = HciTransportMarker;
    type ControlHandle = HciTransportControlHandle;

    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 {
        HciTransportControlHandle { 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 HciTransportRequestStream {
    type Item = Result<HciTransportRequest, 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 HciTransportRequestStream 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 {
                    0x4793b5e66fd79e0b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SentPacket,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SentPacket>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            HciTransportControlHandle { inner: this.inner.clone() };
                        Ok(HciTransportRequest::Send_ {
                            payload: req,
                            responder: HciTransportSend_Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x25de8c1f760f0c89 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            HciTransportControlHandle { inner: this.inner.clone() };
                        Ok(HciTransportRequest::AckReceive { control_handle })
                    }
                    0x4298072d0498b612 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            HciTransportConfigureScoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HciTransportConfigureScoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            HciTransportControlHandle { inner: this.inner.clone() };
                        Ok(HciTransportRequest::ConfigureSco { payload: req, control_handle })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(HciTransportRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: HciTransportControlHandle { 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(HciTransportRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: HciTransportControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <HciTransportMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum HciTransportRequest {
    /// More than one Send can be pending simultaneously.
    /// Prefer to limit the number of pending calls to avoid overflow.
    /// A maximum of 10 pending calls is suggested.
    /// If an event or SCO packet is received by the server, the server should close the protocol.
    Send_ {
        payload: SentPacket,
        responder: HciTransportSend_Responder,
    },
    AckReceive {
        control_handle: HciTransportControlHandle,
    },
    /// Establish a SCO connection. Only 1 SCO connection can be configured at a time.
    ConfigureSco {
        payload: HciTransportConfigureScoRequest,
        control_handle: HciTransportControlHandle,
    },
    /// 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: HciTransportControlHandle,
        method_type: fidl::MethodType,
    },
}

impl HciTransportRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_send_(self) -> Option<(SentPacket, HciTransportSend_Responder)> {
        if let HciTransportRequest::Send_ { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_ack_receive(self) -> Option<(HciTransportControlHandle)> {
        if let HciTransportRequest::AckReceive { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_configure_sco(
        self,
    ) -> Option<(HciTransportConfigureScoRequest, HciTransportControlHandle)> {
        if let HciTransportRequest::ConfigureSco { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

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

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

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

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

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

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

impl HciTransportControlHandle {
    pub fn send_on_receive(&self, mut payload: &ReceivedPacket) -> Result<(), fidl::Error> {
        self.inner.send::<ReceivedPacket>(
            payload,
            0,
            0xcb102e573e5049c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
            fidl::encoding::Flexible::new(()),
            self.tx_id,
            0x4793b5e66fd79e0b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for PeerMarker {
    type Proxy = PeerProxy;
    type RequestStream = PeerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PeerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Peer";
}
pub type PeerSetLeAdvertisementResult = Result<(), EmulatorPeerError>;

pub trait PeerProxyInterface: Send + Sync {
    type AssignConnectionStatusResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#assign_connection_status(
        &self,
        status: HciError,
    ) -> Self::AssignConnectionStatusResponseFut;
    fn r#emulate_le_connection_complete(
        &self,
        role: fidl_fuchsia_bluetooth::ConnectionRole,
    ) -> Result<(), fidl::Error>;
    fn r#emulate_disconnection_complete(&self) -> Result<(), fidl::Error>;
    type WatchConnectionStatesResponseFut: std::future::Future<Output = Result<Vec<ConnectionState>, fidl::Error>>
        + Send;
    fn r#watch_connection_states(&self) -> Self::WatchConnectionStatesResponseFut;
    type SetDeviceClassResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#set_device_class(&self, value: u32) -> Self::SetDeviceClassResponseFut;
    type SetServiceDefinitionsResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#set_service_definitions(
        &self,
        service_definitions: &[fidl_fuchsia_bluetooth_bredr::ServiceDefinition],
    ) -> Self::SetServiceDefinitionsResponseFut;
    type SetLeAdvertisementResponseFut: std::future::Future<Output = Result<PeerSetLeAdvertisementResult, fidl::Error>>
        + Send;
    fn r#set_le_advertisement(
        &self,
        payload: &PeerSetLeAdvertisementRequest,
    ) -> Self::SetLeAdvertisementResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PeerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PeerSynchronousProxy {
    type Proxy = PeerProxy;
    type Protocol = PeerMarker;

    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 PeerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <PeerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// Assign a HCI `status` for the controller to generate in response to connection requests.
    /// Applies to all successive HCI_Create_Connection and HCI_LE_Create_Connection commands. The
    /// procedure is acknowledged with an empty response.
    pub fn r#assign_connection_status(
        &self,
        mut status: HciError,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            PeerAssignConnectionStatusRequest,
            fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
        >(
            (status,),
            0x52810c5ba7a2555c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<PeerMarker>("assign_connection_status")?;
        Ok(_response)
    }

    /// Emulates a LE connection event. Does nothing if the peer is already connected. The
    /// `role` parameter determines the link layer connection role.
    pub fn r#emulate_le_connection_complete(
        &self,
        mut role: fidl_fuchsia_bluetooth::ConnectionRole,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PeerEmulateLeConnectionCompleteRequest>(
            (role,),
            0x3dfba319b8d2fc2a,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    /// Emulate disconnection. Does nothing if the peer is not connected.
    pub fn r#emulate_disconnection_complete(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x4d3955084d85a15c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    /// Returns a vector of the least to most recent controller connection states.
    /// This method returns when there has been a state change since the last invocation of this
    /// method by this client.
    ///
    /// Multiple calls to this method can be outstanding at a given time. All calls will resolve in
    /// a response as soon as there is a change to the scan state.
    pub fn r#watch_connection_states(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<ConnectionState>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<PeerWatchConnectionStatesResponse>,
        >(
            (),
            0x5a5190211980c70f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<PeerMarker>("watch_connection_states")?;
        Ok(_response.states)
    }

    /// Sets the device class reported in the inquiry response for this peer during device
    /// discovery. If the peer is not BR/EDR, the server will close with the `ZX_ERR_NOT_SUPPORTED`
    /// epitaph.
    pub fn r#set_device_class(
        &self,
        mut value: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl_fuchsia_bluetooth::DeviceClass,
            fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
        >(
            (value,),
            0x3e52fa234758e1ea,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<PeerMarker>("set_device_class")?;
        Ok(_response)
    }

    /// Sets the peer's services that will be discoverable via Service Discovery Protocol. If the
    /// peer is not BR/EDR, the server will close with the `ZX_ERR_NOT_SUPPORTED` epitaph.
    pub fn r#set_service_definitions(
        &self,
        mut service_definitions: &[fidl_fuchsia_bluetooth_bredr::ServiceDefinition],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            PeerSetServiceDefinitionsRequest,
            fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
        >(
            (service_definitions,),
            0x58ce9f22fce272df,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<PeerMarker>("set_service_definitions")?;
        Ok(_response)
    }

    pub fn r#set_le_advertisement(
        &self,
        mut payload: &PeerSetLeAdvertisementRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PeerSetLeAdvertisementResult, fidl::Error> {
        let _response = self.client.send_query::<
            PeerSetLeAdvertisementRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, EmulatorPeerError>,
        >(
            payload,
            0x481b9aea1b39cfb4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<PeerMarker>("set_le_advertisement")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PeerProxy {
    type Protocol = PeerMarker;

    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 PeerProxy {
    /// Create a new Proxy for fuchsia.hardware.bluetooth/Peer.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PeerMarker 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) -> PeerEventStream {
        PeerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Assign a HCI `status` for the controller to generate in response to connection requests.
    /// Applies to all successive HCI_Create_Connection and HCI_LE_Create_Connection commands. The
    /// procedure is acknowledged with an empty response.
    pub fn r#assign_connection_status(
        &self,
        mut status: HciError,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        PeerProxyInterface::r#assign_connection_status(self, status)
    }

    /// Emulates a LE connection event. Does nothing if the peer is already connected. The
    /// `role` parameter determines the link layer connection role.
    pub fn r#emulate_le_connection_complete(
        &self,
        mut role: fidl_fuchsia_bluetooth::ConnectionRole,
    ) -> Result<(), fidl::Error> {
        PeerProxyInterface::r#emulate_le_connection_complete(self, role)
    }

    /// Emulate disconnection. Does nothing if the peer is not connected.
    pub fn r#emulate_disconnection_complete(&self) -> Result<(), fidl::Error> {
        PeerProxyInterface::r#emulate_disconnection_complete(self)
    }

    /// Returns a vector of the least to most recent controller connection states.
    /// This method returns when there has been a state change since the last invocation of this
    /// method by this client.
    ///
    /// Multiple calls to this method can be outstanding at a given time. All calls will resolve in
    /// a response as soon as there is a change to the scan state.
    pub fn r#watch_connection_states(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<ConnectionState>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PeerProxyInterface::r#watch_connection_states(self)
    }

    /// Sets the device class reported in the inquiry response for this peer during device
    /// discovery. If the peer is not BR/EDR, the server will close with the `ZX_ERR_NOT_SUPPORTED`
    /// epitaph.
    pub fn r#set_device_class(
        &self,
        mut value: u32,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        PeerProxyInterface::r#set_device_class(self, value)
    }

    /// Sets the peer's services that will be discoverable via Service Discovery Protocol. If the
    /// peer is not BR/EDR, the server will close with the `ZX_ERR_NOT_SUPPORTED` epitaph.
    pub fn r#set_service_definitions(
        &self,
        mut service_definitions: &[fidl_fuchsia_bluetooth_bredr::ServiceDefinition],
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        PeerProxyInterface::r#set_service_definitions(self, service_definitions)
    }

    pub fn r#set_le_advertisement(
        &self,
        mut payload: &PeerSetLeAdvertisementRequest,
    ) -> fidl::client::QueryResponseFut<
        PeerSetLeAdvertisementResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PeerProxyInterface::r#set_le_advertisement(self, payload)
    }
}

impl PeerProxyInterface for PeerProxy {
    type AssignConnectionStatusResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#assign_connection_status(
        &self,
        mut status: HciError,
    ) -> Self::AssignConnectionStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x52810c5ba7a2555c,
            >(_buf?)?
            .into_result::<PeerMarker>("assign_connection_status")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<PeerAssignConnectionStatusRequest, ()>(
            (status,),
            0x52810c5ba7a2555c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    fn r#emulate_le_connection_complete(
        &self,
        mut role: fidl_fuchsia_bluetooth::ConnectionRole,
    ) -> Result<(), fidl::Error> {
        self.client.send::<PeerEmulateLeConnectionCompleteRequest>(
            (role,),
            0x3dfba319b8d2fc2a,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

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

    type WatchConnectionStatesResponseFut = fidl::client::QueryResponseFut<
        Vec<ConnectionState>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_connection_states(&self) -> Self::WatchConnectionStatesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<ConnectionState>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<PeerWatchConnectionStatesResponse>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5a5190211980c70f,
            >(_buf?)?
            .into_result::<PeerMarker>("watch_connection_states")?;
            Ok(_response.states)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<ConnectionState>>(
            (),
            0x5a5190211980c70f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SetDeviceClassResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_device_class(&self, mut value: u32) -> Self::SetDeviceClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3e52fa234758e1ea,
            >(_buf?)?
            .into_result::<PeerMarker>("set_device_class")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl_fuchsia_bluetooth::DeviceClass, ()>(
            (value,),
            0x3e52fa234758e1ea,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SetServiceDefinitionsResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_service_definitions(
        &self,
        mut service_definitions: &[fidl_fuchsia_bluetooth_bredr::ServiceDefinition],
    ) -> Self::SetServiceDefinitionsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x58ce9f22fce272df,
            >(_buf?)?
            .into_result::<PeerMarker>("set_service_definitions")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<PeerSetServiceDefinitionsRequest, ()>(
            (service_definitions,),
            0x58ce9f22fce272df,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SetLeAdvertisementResponseFut = fidl::client::QueryResponseFut<
        PeerSetLeAdvertisementResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_le_advertisement(
        &self,
        mut payload: &PeerSetLeAdvertisementRequest,
    ) -> Self::SetLeAdvertisementResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PeerSetLeAdvertisementResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, EmulatorPeerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x481b9aea1b39cfb4,
            >(_buf?)?
            .into_result::<PeerMarker>("set_le_advertisement")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<PeerSetLeAdvertisementRequest, PeerSetLeAdvertisementResult>(
                payload,
                0x481b9aea1b39cfb4,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.bluetooth/Peer.
pub struct PeerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for PeerRequestStream {
    type Protocol = PeerMarker;
    type ControlHandle = PeerControlHandle;

    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 {
        PeerControlHandle { 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 PeerRequestStream {
    type Item = Result<PeerRequest, 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 PeerRequestStream 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 {
                    0x52810c5ba7a2555c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PeerAssignConnectionStatusRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeerAssignConnectionStatusRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerControlHandle { inner: this.inner.clone() };
                        Ok(PeerRequest::AssignConnectionStatus {
                            status: req.status,

                            responder: PeerAssignConnectionStatusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3dfba319b8d2fc2a => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            PeerEmulateLeConnectionCompleteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeerEmulateLeConnectionCompleteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerControlHandle { inner: this.inner.clone() };
                        Ok(PeerRequest::EmulateLeConnectionComplete {
                            role: req.role,

                            control_handle,
                        })
                    }
                    0x4d3955084d85a15c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerControlHandle { inner: this.inner.clone() };
                        Ok(PeerRequest::EmulateDisconnectionComplete { control_handle })
                    }
                    0x5a5190211980c70f => {
                        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 = PeerControlHandle { inner: this.inner.clone() };
                        Ok(PeerRequest::WatchConnectionStates {
                            responder: PeerWatchConnectionStatesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3e52fa234758e1ea => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl_fuchsia_bluetooth::DeviceClass,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_bluetooth::DeviceClass>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerControlHandle { inner: this.inner.clone() };
                        Ok(PeerRequest::SetDeviceClass {
                            value: req.value,

                            responder: PeerSetDeviceClassResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x58ce9f22fce272df => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PeerSetServiceDefinitionsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeerSetServiceDefinitionsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerControlHandle { inner: this.inner.clone() };
                        Ok(PeerRequest::SetServiceDefinitions {
                            service_definitions: req.service_definitions,

                            responder: PeerSetServiceDefinitionsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x481b9aea1b39cfb4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PeerSetLeAdvertisementRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeerSetLeAdvertisementRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeerControlHandle { inner: this.inner.clone() };
                        Ok(PeerRequest::SetLeAdvertisement {
                            payload: req,
                            responder: PeerSetLeAdvertisementResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(PeerRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: PeerControlHandle { 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(PeerRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: PeerControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name: <PeerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol used to drive the state of a fake peer device.
#[derive(Debug)]
pub enum PeerRequest {
    /// Assign a HCI `status` for the controller to generate in response to connection requests.
    /// Applies to all successive HCI_Create_Connection and HCI_LE_Create_Connection commands. The
    /// procedure is acknowledged with an empty response.
    AssignConnectionStatus { status: HciError, responder: PeerAssignConnectionStatusResponder },
    /// Emulates a LE connection event. Does nothing if the peer is already connected. The
    /// `role` parameter determines the link layer connection role.
    EmulateLeConnectionComplete {
        role: fidl_fuchsia_bluetooth::ConnectionRole,
        control_handle: PeerControlHandle,
    },
    /// Emulate disconnection. Does nothing if the peer is not connected.
    EmulateDisconnectionComplete { control_handle: PeerControlHandle },
    /// Returns a vector of the least to most recent controller connection states.
    /// This method returns when there has been a state change since the last invocation of this
    /// method by this client.
    ///
    /// Multiple calls to this method can be outstanding at a given time. All calls will resolve in
    /// a response as soon as there is a change to the scan state.
    WatchConnectionStates { responder: PeerWatchConnectionStatesResponder },
    /// Sets the device class reported in the inquiry response for this peer during device
    /// discovery. If the peer is not BR/EDR, the server will close with the `ZX_ERR_NOT_SUPPORTED`
    /// epitaph.
    SetDeviceClass { value: u32, responder: PeerSetDeviceClassResponder },
    /// Sets the peer's services that will be discoverable via Service Discovery Protocol. If the
    /// peer is not BR/EDR, the server will close with the `ZX_ERR_NOT_SUPPORTED` epitaph.
    SetServiceDefinitions {
        service_definitions: Vec<fidl_fuchsia_bluetooth_bredr::ServiceDefinition>,
        responder: PeerSetServiceDefinitionsResponder,
    },
    SetLeAdvertisement {
        payload: PeerSetLeAdvertisementRequest,
        responder: PeerSetLeAdvertisementResponder,
    },
    /// 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: PeerControlHandle,
        method_type: fidl::MethodType,
    },
}

impl PeerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_assign_connection_status(
        self,
    ) -> Option<(HciError, PeerAssignConnectionStatusResponder)> {
        if let PeerRequest::AssignConnectionStatus { status, responder } = self {
            Some((status, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_emulate_le_connection_complete(
        self,
    ) -> Option<(fidl_fuchsia_bluetooth::ConnectionRole, PeerControlHandle)> {
        if let PeerRequest::EmulateLeConnectionComplete { role, control_handle } = self {
            Some((role, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_emulate_disconnection_complete(self) -> Option<(PeerControlHandle)> {
        if let PeerRequest::EmulateDisconnectionComplete { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_connection_states(self) -> Option<(PeerWatchConnectionStatesResponder)> {
        if let PeerRequest::WatchConnectionStates { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_device_class(self) -> Option<(u32, PeerSetDeviceClassResponder)> {
        if let PeerRequest::SetDeviceClass { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_service_definitions(
        self,
    ) -> Option<(
        Vec<fidl_fuchsia_bluetooth_bredr::ServiceDefinition>,
        PeerSetServiceDefinitionsResponder,
    )> {
        if let PeerRequest::SetServiceDefinitions { service_definitions, responder } = self {
            Some((service_definitions, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_le_advertisement(
        self,
    ) -> Option<(PeerSetLeAdvertisementRequest, PeerSetLeAdvertisementResponder)> {
        if let PeerRequest::SetLeAdvertisement { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PeerRequest::AssignConnectionStatus { .. } => "assign_connection_status",
            PeerRequest::EmulateLeConnectionComplete { .. } => "emulate_le_connection_complete",
            PeerRequest::EmulateDisconnectionComplete { .. } => "emulate_disconnection_complete",
            PeerRequest::WatchConnectionStates { .. } => "watch_connection_states",
            PeerRequest::SetDeviceClass { .. } => "set_device_class",
            PeerRequest::SetServiceDefinitions { .. } => "set_service_definitions",
            PeerRequest::SetLeAdvertisement { .. } => "set_le_advertisement",
            PeerRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            PeerRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

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

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

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

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

impl PeerControlHandle {}

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

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

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

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
            fidl::encoding::Flexible::new(()),
            self.tx_id,
            0x52810c5ba7a2555c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(&self, mut states: &[ConnectionState]) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleType<PeerWatchConnectionStatesResponse>>(
                fidl::encoding::Flexible::new((states,)),
                self.tx_id,
                0x5a5190211980c70f,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
            fidl::encoding::Flexible::new(()),
            self.tx_id,
            0x3e52fa234758e1ea,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
            fidl::encoding::Flexible::new(()),
            self.tx_id,
            0x58ce9f22fce272df,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<(), EmulatorPeerError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            fidl::encoding::EmptyStruct,
            EmulatorPeerError,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x481b9aea1b39cfb4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for ScoConnectionMarker {
    type Proxy = ScoConnectionProxy;
    type RequestStream = ScoConnectionRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ScoConnectionSynchronousProxy;

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

pub trait ScoConnectionProxyInterface: Send + Sync {
    type Send_ResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#send_(&self, packet: &[u8]) -> Self::Send_ResponseFut;
    fn r#ack_receive(&self) -> Result<(), fidl::Error>;
    fn r#stop(&self) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ScoConnectionSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ScoConnectionSynchronousProxy {
    type Proxy = ScoConnectionProxy;
    type Protocol = ScoConnectionMarker;

    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 ScoConnectionSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ScoConnectionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// More than one Send can be pending simultaneously.
    /// Prefer to limit the number of pending calls to avoid overflow.
    /// A maximum of 10 pending calls is suggested.
    pub fn r#send_(
        &self,
        mut packet: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<ScoPacket, fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
                (packet,),
                0x6e0c000ccd50adec,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                ___deadline,
            )?
            .into_result::<ScoConnectionMarker>("send_")?;
        Ok(_response)
    }

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

    /// The server will close the protocol when `Stop` is received. This is useful for
    /// synchronization (e.g. before configuring another `ScoConnection`).
    pub fn r#stop(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x5df8b0ab265b449d,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ScoConnectionProxy {
    type Protocol = ScoConnectionMarker;

    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 ScoConnectionProxy {
    /// Create a new Proxy for fuchsia.hardware.bluetooth/ScoConnection.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ScoConnectionMarker 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) -> ScoConnectionEventStream {
        ScoConnectionEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// More than one Send can be pending simultaneously.
    /// Prefer to limit the number of pending calls to avoid overflow.
    /// A maximum of 10 pending calls is suggested.
    pub fn r#send_(
        &self,
        mut packet: &[u8],
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        ScoConnectionProxyInterface::r#send_(self, packet)
    }

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

    /// The server will close the protocol when `Stop` is received. This is useful for
    /// synchronization (e.g. before configuring another `ScoConnection`).
    pub fn r#stop(&self) -> Result<(), fidl::Error> {
        ScoConnectionProxyInterface::r#stop(self)
    }
}

impl ScoConnectionProxyInterface for ScoConnectionProxy {
    type Send_ResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#send_(&self, mut packet: &[u8]) -> Self::Send_ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6e0c000ccd50adec,
            >(_buf?)?
            .into_result::<ScoConnectionMarker>("send_")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<ScoPacket, ()>(
            (packet,),
            0x6e0c000ccd50adec,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

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

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

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

#[derive(Debug)]
pub enum ScoConnectionEvent {
    OnReceive {
        packet: Vec<u8>,
    },
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl ScoConnectionEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_receive(self) -> Option<Vec<u8>> {
        if let ScoConnectionEvent::OnReceive { packet } = self { Some((packet)) } else { None }
    }

    /// Decodes a message buffer as a [`ScoConnectionEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ScoConnectionEvent, 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 {
            0x4d4e96f6f7d1aa12 => {
                let mut out =
                    fidl::new_empty!(ScoPacket, fidl::encoding::DefaultFuchsiaResourceDialect);
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ScoPacket>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((ScoConnectionEvent::OnReceive { packet: out.packet }))
            }
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(ScoConnectionEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <ScoConnectionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.hardware.bluetooth/ScoConnection.
pub struct ScoConnectionRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ScoConnectionRequestStream {
    type Protocol = ScoConnectionMarker;
    type ControlHandle = ScoConnectionControlHandle;

    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 {
        ScoConnectionControlHandle { 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 ScoConnectionRequestStream {
    type Item = Result<ScoConnectionRequest, 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 ScoConnectionRequestStream 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 {
                    0x6e0c000ccd50adec => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ScoPacket,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ScoPacket>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ScoConnectionControlHandle { inner: this.inner.clone() };
                        Ok(ScoConnectionRequest::Send_ {
                            packet: req.packet,

                            responder: ScoConnectionSend_Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7e6af45151224a6a => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ScoConnectionControlHandle { inner: this.inner.clone() };
                        Ok(ScoConnectionRequest::AckReceive { control_handle })
                    }
                    0x5df8b0ab265b449d => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ScoConnectionControlHandle { inner: this.inner.clone() };
                        Ok(ScoConnectionRequest::Stop { control_handle })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(ScoConnectionRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ScoConnectionControlHandle {
                                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(ScoConnectionRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ScoConnectionControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ScoConnectionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum ScoConnectionRequest {
    /// More than one Send can be pending simultaneously.
    /// Prefer to limit the number of pending calls to avoid overflow.
    /// A maximum of 10 pending calls is suggested.
    Send_ {
        packet: Vec<u8>,
        responder: ScoConnectionSend_Responder,
    },
    AckReceive {
        control_handle: ScoConnectionControlHandle,
    },
    /// The server will close the protocol when `Stop` is received. This is useful for
    /// synchronization (e.g. before configuring another `ScoConnection`).
    Stop {
        control_handle: ScoConnectionControlHandle,
    },
    /// 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: ScoConnectionControlHandle,
        method_type: fidl::MethodType,
    },
}

impl ScoConnectionRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_send_(self) -> Option<(Vec<u8>, ScoConnectionSend_Responder)> {
        if let ScoConnectionRequest::Send_ { packet, responder } = self {
            Some((packet, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_ack_receive(self) -> Option<(ScoConnectionControlHandle)> {
        if let ScoConnectionRequest::AckReceive { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop(self) -> Option<(ScoConnectionControlHandle)> {
        if let ScoConnectionRequest::Stop { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

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

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

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

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

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

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

impl ScoConnectionControlHandle {
    pub fn send_on_receive(&self, mut packet: &[u8]) -> Result<(), fidl::Error> {
        self.inner.send::<ScoPacket>(
            (packet,),
            0,
            0x4d4e96f6f7d1aa12,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
            fidl::encoding::Flexible::new(()),
            self.tx_id,
            0x6e0c000ccd50adec,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for SnoopMarker {
    type Proxy = SnoopProxy;
    type RequestStream = SnoopRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SnoopSynchronousProxy;

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

pub trait SnoopProxyInterface: Send + Sync {
    fn r#acknowledge_packets(&self, sequence: u64) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SnoopSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SnoopSynchronousProxy {
    type Proxy = SnoopProxy;
    type Protocol = SnoopMarker;

    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 SnoopSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <SnoopMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// Acknowledge packets have been received up to `sequence`.
    pub fn r#acknowledge_packets(&self, mut sequence: u64) -> Result<(), fidl::Error> {
        self.client.send::<SnoopAcknowledgePacketsRequest>(
            (sequence,),
            0x3336b5082c111286,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for SnoopProxy {
    type Protocol = SnoopMarker;

    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 SnoopProxy {
    /// Create a new Proxy for fuchsia.hardware.bluetooth/Snoop.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <SnoopMarker 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) -> SnoopEventStream {
        SnoopEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Acknowledge packets have been received up to `sequence`.
    pub fn r#acknowledge_packets(&self, mut sequence: u64) -> Result<(), fidl::Error> {
        SnoopProxyInterface::r#acknowledge_packets(self, sequence)
    }
}

impl SnoopProxyInterface for SnoopProxy {
    fn r#acknowledge_packets(&self, mut sequence: u64) -> Result<(), fidl::Error> {
        self.client.send::<SnoopAcknowledgePacketsRequest>(
            (sequence,),
            0x3336b5082c111286,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum SnoopEvent {
    OnObservePacket {
        payload: SnoopOnObservePacketRequest,
    },
    OnDroppedPackets {
        payload: SnoopOnDroppedPacketsRequest,
    },
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl SnoopEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_observe_packet(self) -> Option<SnoopOnObservePacketRequest> {
        if let SnoopEvent::OnObservePacket { payload } = self { Some((payload)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_dropped_packets(self) -> Option<SnoopOnDroppedPacketsRequest> {
        if let SnoopEvent::OnDroppedPackets { payload } = self { Some((payload)) } else { None }
    }

    /// Decodes a message buffer as a [`SnoopEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<SnoopEvent, 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 {
            0x34d9f4c9c6bc10ca => {
                let mut out = fidl::new_empty!(
                    SnoopOnObservePacketRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SnoopOnObservePacketRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((SnoopEvent::OnObservePacket { payload: out }))
            }
            0x102a8d21278578b9 => {
                let mut out = fidl::new_empty!(
                    SnoopOnDroppedPacketsRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SnoopOnDroppedPacketsRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((SnoopEvent::OnDroppedPackets { payload: out }))
            }
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(SnoopEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <SnoopMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.hardware.bluetooth/Snoop.
pub struct SnoopRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for SnoopRequestStream {
    type Protocol = SnoopMarker;
    type ControlHandle = SnoopControlHandle;

    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 {
        SnoopControlHandle { 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 SnoopRequestStream {
    type Item = Result<SnoopRequest, 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 SnoopRequestStream 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 {
                    0x3336b5082c111286 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            SnoopAcknowledgePacketsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SnoopAcknowledgePacketsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SnoopControlHandle { inner: this.inner.clone() };
                        Ok(SnoopRequest::AcknowledgePackets {
                            sequence: req.sequence,

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

#[derive(Debug)]
pub enum SnoopRequest {
    /// Acknowledge packets have been received up to `sequence`.
    AcknowledgePackets { sequence: u64, control_handle: SnoopControlHandle },
    /// 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: SnoopControlHandle,
        method_type: fidl::MethodType,
    },
}

impl SnoopRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_acknowledge_packets(self) -> Option<(u64, SnoopControlHandle)> {
        if let SnoopRequest::AcknowledgePackets { sequence, control_handle } = self {
            Some((sequence, control_handle))
        } else {
            None
        }
    }

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

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

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

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

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

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

impl SnoopControlHandle {
    pub fn send_on_observe_packet(
        &self,
        mut payload: &SnoopOnObservePacketRequest,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<SnoopOnObservePacketRequest>(
            payload,
            0,
            0x34d9f4c9c6bc10ca,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    pub fn send_on_dropped_packets(
        &self,
        mut payload: &SnoopOnDroppedPacketsRequest,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<SnoopOnDroppedPacketsRequest>(
            payload,
            0,
            0x102a8d21278578b9,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for VendorMarker {
    type Proxy = VendorProxy;
    type RequestStream = VendorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = VendorSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Vendor";
}
pub type VendorEncodeCommandResult = Result<Vec<u8>, i32>;
pub type VendorOpenHciResult = Result<fidl::endpoints::ClientEnd<HciMarker>, i32>;
pub type VendorOpenHciTransportResult = Result<fidl::endpoints::ClientEnd<HciTransportMarker>, i32>;
pub type VendorOpenSnoopResult = Result<fidl::endpoints::ClientEnd<SnoopMarker>, i32>;

pub trait VendorProxyInterface: Send + Sync {
    type GetFeaturesResponseFut: std::future::Future<Output = Result<VendorFeatures, fidl::Error>>
        + Send;
    fn r#get_features(&self) -> Self::GetFeaturesResponseFut;
    type EncodeCommandResponseFut: std::future::Future<Output = Result<VendorEncodeCommandResult, fidl::Error>>
        + Send;
    fn r#encode_command(&self, payload: &VendorCommand) -> Self::EncodeCommandResponseFut;
    type OpenHciResponseFut: std::future::Future<Output = Result<VendorOpenHciResult, fidl::Error>>
        + Send;
    fn r#open_hci(&self) -> Self::OpenHciResponseFut;
    type OpenHciTransportResponseFut: std::future::Future<Output = Result<VendorOpenHciTransportResult, fidl::Error>>
        + Send;
    fn r#open_hci_transport(&self) -> Self::OpenHciTransportResponseFut;
    type OpenSnoopResponseFut: std::future::Future<Output = Result<VendorOpenSnoopResult, fidl::Error>>
        + Send;
    fn r#open_snoop(&self) -> Self::OpenSnoopResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct VendorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for VendorSynchronousProxy {
    type Proxy = VendorProxy;
    type Protocol = VendorMarker;

    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 VendorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <VendorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// Returns the Vendor Features supported by this controller.
    pub fn r#get_features(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<VendorFeatures, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<VendorFeatures>,
        >(
            (),
            0x102e70164c1dc911,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<VendorMarker>("get_features")?;
        Ok(_response)
    }

    /// Encode the vendor HCI command and return the encoded command.
    /// See `VendorCommand` for possible commands and parameters.
    /// * error `ZX_ERR_NOT_SUPPORTED` The command is not supported.
    /// * error `ZX_ERR_INVALID_ARGS` The parameters of the command are invalid.
    pub fn r#encode_command(
        &self,
        mut payload: &VendorCommand,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<VendorEncodeCommandResult, fidl::Error> {
        let _response = self.client.send_query::<
            VendorCommand,
            fidl::encoding::FlexibleResultType<VendorEncodeCommandResponse, i32>,
        >(
            payload,
            0x75430542c197cbe8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<VendorMarker>("encode_command")?;
        Ok(_response.map(|x| x.encoded))
    }

    /// Deprecated.
    /// Open the HCI protocol to the controller.  This call may block until the
    /// controller has been initialized.
    /// Returns ALREADY_BOUND if another client has already connected.
    pub fn r#open_hci(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<VendorOpenHciResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<VendorOpenHciResponse, i32>,
        >(
            (),
            0x7f05862f7ef92ec8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<VendorMarker>("open_hci")?;
        Ok(_response.map(|x| x.channel))
    }

    /// Open the HciTransport protocol to the controller. This call may block until the
    /// controller has been initialized.
    /// Returns ALREADY_BOUND if another client has already connected.
    pub fn r#open_hci_transport(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<VendorOpenHciTransportResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<VendorOpenHciTransportResponse, i32>,
        >(
            (),
            0x1f785b656fb00834,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<VendorMarker>("open_hci_transport")?;
        Ok(_response.map(|x| x.channel))
    }

    /// Open the Snoop protocol to the transport driver.
    /// Returns ALREADY_BOUND if another client has already connected.
    pub fn r#open_snoop(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<VendorOpenSnoopResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<VendorOpenSnoopResponse, i32>,
        >(
            (),
            0xafeca0e3c789043,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<VendorMarker>("open_snoop")?;
        Ok(_response.map(|x| x.channel))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for VendorProxy {
    type Protocol = VendorMarker;

    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 VendorProxy {
    /// Create a new Proxy for fuchsia.hardware.bluetooth/Vendor.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <VendorMarker 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) -> VendorEventStream {
        VendorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns the Vendor Features supported by this controller.
    pub fn r#get_features(
        &self,
    ) -> fidl::client::QueryResponseFut<VendorFeatures, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        VendorProxyInterface::r#get_features(self)
    }

    /// Encode the vendor HCI command and return the encoded command.
    /// See `VendorCommand` for possible commands and parameters.
    /// * error `ZX_ERR_NOT_SUPPORTED` The command is not supported.
    /// * error `ZX_ERR_INVALID_ARGS` The parameters of the command are invalid.
    pub fn r#encode_command(
        &self,
        mut payload: &VendorCommand,
    ) -> fidl::client::QueryResponseFut<
        VendorEncodeCommandResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        VendorProxyInterface::r#encode_command(self, payload)
    }

    /// Deprecated.
    /// Open the HCI protocol to the controller.  This call may block until the
    /// controller has been initialized.
    /// Returns ALREADY_BOUND if another client has already connected.
    pub fn r#open_hci(
        &self,
    ) -> fidl::client::QueryResponseFut<
        VendorOpenHciResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        VendorProxyInterface::r#open_hci(self)
    }

    /// Open the HciTransport protocol to the controller. This call may block until the
    /// controller has been initialized.
    /// Returns ALREADY_BOUND if another client has already connected.
    pub fn r#open_hci_transport(
        &self,
    ) -> fidl::client::QueryResponseFut<
        VendorOpenHciTransportResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        VendorProxyInterface::r#open_hci_transport(self)
    }

    /// Open the Snoop protocol to the transport driver.
    /// Returns ALREADY_BOUND if another client has already connected.
    pub fn r#open_snoop(
        &self,
    ) -> fidl::client::QueryResponseFut<
        VendorOpenSnoopResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        VendorProxyInterface::r#open_snoop(self)
    }
}

impl VendorProxyInterface for VendorProxy {
    type GetFeaturesResponseFut = fidl::client::QueryResponseFut<
        VendorFeatures,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_features(&self) -> Self::GetFeaturesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<VendorFeatures, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<VendorFeatures>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x102e70164c1dc911,
            >(_buf?)?
            .into_result::<VendorMarker>("get_features")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, VendorFeatures>(
            (),
            0x102e70164c1dc911,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type EncodeCommandResponseFut = fidl::client::QueryResponseFut<
        VendorEncodeCommandResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#encode_command(&self, mut payload: &VendorCommand) -> Self::EncodeCommandResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<VendorEncodeCommandResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<VendorEncodeCommandResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x75430542c197cbe8,
            >(_buf?)?
            .into_result::<VendorMarker>("encode_command")?;
            Ok(_response.map(|x| x.encoded))
        }
        self.client.send_query_and_decode::<VendorCommand, VendorEncodeCommandResult>(
            payload,
            0x75430542c197cbe8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type OpenHciResponseFut = fidl::client::QueryResponseFut<
        VendorOpenHciResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_hci(&self) -> Self::OpenHciResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<VendorOpenHciResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<VendorOpenHciResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7f05862f7ef92ec8,
            >(_buf?)?
            .into_result::<VendorMarker>("open_hci")?;
            Ok(_response.map(|x| x.channel))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, VendorOpenHciResult>(
            (),
            0x7f05862f7ef92ec8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type OpenHciTransportResponseFut = fidl::client::QueryResponseFut<
        VendorOpenHciTransportResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_hci_transport(&self) -> Self::OpenHciTransportResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<VendorOpenHciTransportResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<VendorOpenHciTransportResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1f785b656fb00834,
            >(_buf?)?
            .into_result::<VendorMarker>("open_hci_transport")?;
            Ok(_response.map(|x| x.channel))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, VendorOpenHciTransportResult>(
                (),
                0x1f785b656fb00834,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type OpenSnoopResponseFut = fidl::client::QueryResponseFut<
        VendorOpenSnoopResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_snoop(&self) -> Self::OpenSnoopResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<VendorOpenSnoopResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<VendorOpenSnoopResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xafeca0e3c789043,
            >(_buf?)?
            .into_result::<VendorMarker>("open_snoop")?;
            Ok(_response.map(|x| x.channel))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, VendorOpenSnoopResult>(
            (),
            0xafeca0e3c789043,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.bluetooth/Vendor.
pub struct VendorRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for VendorRequestStream {
    type Protocol = VendorMarker;
    type ControlHandle = VendorControlHandle;

    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 {
        VendorControlHandle { 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 VendorRequestStream {
    type Item = Result<VendorRequest, 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 VendorRequestStream 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 {
                    0x102e70164c1dc911 => {
                        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 = VendorControlHandle { inner: this.inner.clone() };
                        Ok(VendorRequest::GetFeatures {
                            responder: VendorGetFeaturesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x75430542c197cbe8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            VendorCommand,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VendorCommand>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = VendorControlHandle { inner: this.inner.clone() };
                        Ok(VendorRequest::EncodeCommand {
                            payload: req,
                            responder: VendorEncodeCommandResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7f05862f7ef92ec8 => {
                        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 = VendorControlHandle { inner: this.inner.clone() };
                        Ok(VendorRequest::OpenHci {
                            responder: VendorOpenHciResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1f785b656fb00834 => {
                        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 = VendorControlHandle { inner: this.inner.clone() };
                        Ok(VendorRequest::OpenHciTransport {
                            responder: VendorOpenHciTransportResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xafeca0e3c789043 => {
                        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 = VendorControlHandle { inner: this.inner.clone() };
                        Ok(VendorRequest::OpenSnoop {
                            responder: VendorOpenSnoopResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(VendorRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: VendorControlHandle { 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(VendorRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: VendorControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <VendorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// The BtVendor protocol may be implemented by vendor drivers to support feature interrogation
/// and vendor command encoding.
#[derive(Debug)]
pub enum VendorRequest {
    /// Returns the Vendor Features supported by this controller.
    GetFeatures { responder: VendorGetFeaturesResponder },
    /// Encode the vendor HCI command and return the encoded command.
    /// See `VendorCommand` for possible commands and parameters.
    /// * error `ZX_ERR_NOT_SUPPORTED` The command is not supported.
    /// * error `ZX_ERR_INVALID_ARGS` The parameters of the command are invalid.
    EncodeCommand { payload: VendorCommand, responder: VendorEncodeCommandResponder },
    /// Deprecated.
    /// Open the HCI protocol to the controller.  This call may block until the
    /// controller has been initialized.
    /// Returns ALREADY_BOUND if another client has already connected.
    OpenHci { responder: VendorOpenHciResponder },
    /// Open the HciTransport protocol to the controller. This call may block until the
    /// controller has been initialized.
    /// Returns ALREADY_BOUND if another client has already connected.
    OpenHciTransport { responder: VendorOpenHciTransportResponder },
    /// Open the Snoop protocol to the transport driver.
    /// Returns ALREADY_BOUND if another client has already connected.
    OpenSnoop { responder: VendorOpenSnoopResponder },
    /// 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: VendorControlHandle,
        method_type: fidl::MethodType,
    },
}

impl VendorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_features(self) -> Option<(VendorGetFeaturesResponder)> {
        if let VendorRequest::GetFeatures { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_encode_command(self) -> Option<(VendorCommand, VendorEncodeCommandResponder)> {
        if let VendorRequest::EncodeCommand { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_hci(self) -> Option<(VendorOpenHciResponder)> {
        if let VendorRequest::OpenHci { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_hci_transport(self) -> Option<(VendorOpenHciTransportResponder)> {
        if let VendorRequest::OpenHciTransport { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_snoop(self) -> Option<(VendorOpenSnoopResponder)> {
        if let VendorRequest::OpenSnoop { responder } = self { Some((responder)) } else { None }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            VendorRequest::GetFeatures { .. } => "get_features",
            VendorRequest::EncodeCommand { .. } => "encode_command",
            VendorRequest::OpenHci { .. } => "open_hci",
            VendorRequest::OpenHciTransport { .. } => "open_hci_transport",
            VendorRequest::OpenSnoop { .. } => "open_snoop",
            VendorRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            VendorRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

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

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

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

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

impl VendorControlHandle {}

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

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

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

    fn send_raw(&self, mut payload: &VendorFeatures) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<VendorFeatures>>(
            fidl::encoding::Flexible::new(payload),
            self.tx_id,
            0x102e70164c1dc911,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut result: Result<&[u8], i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            VendorEncodeCommandResponse,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result.map(|encoded| (encoded,))),
            self.tx_id,
            0x75430542c197cbe8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut result: Result<fidl::endpoints::ClientEnd<HciMarker>, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleResultType<VendorOpenHciResponse, i32>>(
                fidl::encoding::FlexibleResult::new(result.map(|channel| (channel,))),
                self.tx_id,
                0x7f05862f7ef92ec8,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut result: Result<fidl::endpoints::ClientEnd<HciTransportMarker>, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            VendorOpenHciTransportResponse,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result.map(|channel| (channel,))),
            self.tx_id,
            0x1f785b656fb00834,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut result: Result<fidl::endpoints::ClientEnd<SnoopMarker>, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleResultType<VendorOpenSnoopResponse, i32>>(
                fidl::encoding::FlexibleResult::new(result.map(|channel| (channel,))),
                self.tx_id,
                0xafeca0e3c789043,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

impl fidl::endpoints::ProtocolMarker for VirtualControllerMarker {
    type Proxy = VirtualControllerProxy;
    type RequestStream = VirtualControllerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = VirtualControllerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) VirtualController";
}
pub type VirtualControllerCreateEmulatorResult = Result<Option<String>, i32>;

pub trait VirtualControllerProxyInterface: Send + Sync {
    type CreateEmulatorResponseFut: std::future::Future<Output = Result<VirtualControllerCreateEmulatorResult, fidl::Error>>
        + Send;
    fn r#create_emulator(&self) -> Self::CreateEmulatorResponseFut;
    fn r#create_loopback_device(
        &self,
        payload: VirtualControllerCreateLoopbackDeviceRequest,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct VirtualControllerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for VirtualControllerSynchronousProxy {
    type Proxy = VirtualControllerProxy;
    type Protocol = VirtualControllerMarker;

    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 VirtualControllerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <VirtualControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

    /// Creates a child device, and returns the name of the child created.
    pub fn r#create_emulator(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<VirtualControllerCreateEmulatorResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<VirtualControllerCreateEmulatorResponse, i32>,
        >(
            (),
            0x130273fc0a35cedb,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<VirtualControllerMarker>("create_emulator")?;
        Ok(_response.map(|x| x.name))
    }

    /// Creates a virtual Bluetooth serial device, speaking the BT HCI UART
    /// protocol on the provided handle.
    /// The zircon channel is closed in the event of an error.
    pub fn r#create_loopback_device(
        &self,
        mut payload: VirtualControllerCreateLoopbackDeviceRequest,
    ) -> Result<(), fidl::Error> {
        self.client.send::<VirtualControllerCreateLoopbackDeviceRequest>(
            &mut payload,
            0x7525af8edecb6c0c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for VirtualControllerProxy {
    type Protocol = VirtualControllerMarker;

    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 VirtualControllerProxy {
    /// Create a new Proxy for fuchsia.hardware.bluetooth/VirtualController.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <VirtualControllerMarker 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) -> VirtualControllerEventStream {
        VirtualControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates a child device, and returns the name of the child created.
    pub fn r#create_emulator(
        &self,
    ) -> fidl::client::QueryResponseFut<
        VirtualControllerCreateEmulatorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        VirtualControllerProxyInterface::r#create_emulator(self)
    }

    /// Creates a virtual Bluetooth serial device, speaking the BT HCI UART
    /// protocol on the provided handle.
    /// The zircon channel is closed in the event of an error.
    pub fn r#create_loopback_device(
        &self,
        mut payload: VirtualControllerCreateLoopbackDeviceRequest,
    ) -> Result<(), fidl::Error> {
        VirtualControllerProxyInterface::r#create_loopback_device(self, payload)
    }
}

impl VirtualControllerProxyInterface for VirtualControllerProxy {
    type CreateEmulatorResponseFut = fidl::client::QueryResponseFut<
        VirtualControllerCreateEmulatorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_emulator(&self) -> Self::CreateEmulatorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<VirtualControllerCreateEmulatorResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<VirtualControllerCreateEmulatorResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x130273fc0a35cedb,
            >(_buf?)?
            .into_result::<VirtualControllerMarker>("create_emulator")?;
            Ok(_response.map(|x| x.name))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            VirtualControllerCreateEmulatorResult,
        >(
            (),
            0x130273fc0a35cedb,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    fn r#create_loopback_device(
        &self,
        mut payload: VirtualControllerCreateLoopbackDeviceRequest,
    ) -> Result<(), fidl::Error> {
        self.client.send::<VirtualControllerCreateLoopbackDeviceRequest>(
            &mut payload,
            0x7525af8edecb6c0c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.hardware.bluetooth/VirtualController.
pub struct VirtualControllerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for VirtualControllerRequestStream {
    type Protocol = VirtualControllerMarker;
    type ControlHandle = VirtualControllerControlHandle;

    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 {
        VirtualControllerControlHandle { 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 VirtualControllerRequestStream {
    type Item = Result<VirtualControllerRequest, 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 VirtualControllerRequestStream 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 {
                    0x130273fc0a35cedb => {
                        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 =
                            VirtualControllerControlHandle { inner: this.inner.clone() };
                        Ok(VirtualControllerRequest::CreateEmulator {
                            responder: VirtualControllerCreateEmulatorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7525af8edecb6c0c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            VirtualControllerCreateLoopbackDeviceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<VirtualControllerCreateLoopbackDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            VirtualControllerControlHandle { inner: this.inner.clone() };
                        Ok(VirtualControllerRequest::CreateLoopbackDevice {
                            payload: req,
                            control_handle,
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(VirtualControllerRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: VirtualControllerControlHandle {
                                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(VirtualControllerRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: VirtualControllerControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <VirtualControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Used for spawning virtual Bluetooth devices.
#[derive(Debug)]
pub enum VirtualControllerRequest {
    /// Creates a child device, and returns the name of the child created.
    CreateEmulator { responder: VirtualControllerCreateEmulatorResponder },
    /// Creates a virtual Bluetooth serial device, speaking the BT HCI UART
    /// protocol on the provided handle.
    /// The zircon channel is closed in the event of an error.
    CreateLoopbackDevice {
        payload: VirtualControllerCreateLoopbackDeviceRequest,
        control_handle: VirtualControllerControlHandle,
    },
    /// 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: VirtualControllerControlHandle,
        method_type: fidl::MethodType,
    },
}

impl VirtualControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_emulator(self) -> Option<(VirtualControllerCreateEmulatorResponder)> {
        if let VirtualControllerRequest::CreateEmulator { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_loopback_device(
        self,
    ) -> Option<(VirtualControllerCreateLoopbackDeviceRequest, VirtualControllerControlHandle)>
    {
        if let VirtualControllerRequest::CreateLoopbackDevice { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

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

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

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

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

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

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

impl VirtualControllerControlHandle {}

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

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

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

    fn send_raw(&self, mut result: Result<Option<&str>, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            VirtualControllerCreateEmulatorResponse,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result.map(|name| (name,))),
            self.tx_id,
            0x130273fc0a35cedb,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for EmulatorServiceMarker {
    type Proxy = EmulatorServiceProxy;
    type Request = EmulatorServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.bluetooth.EmulatorService";
}

/// A request for one of the member protocols of EmulatorService.
///
#[cfg(target_os = "fuchsia")]
pub enum EmulatorServiceRequest {
    Device(EmulatorRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for EmulatorServiceRequest {
    type Service = EmulatorServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "device" => Self::Device(
                <EmulatorRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            _ => panic!("no such member protocol name for service EmulatorService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["device"]
    }
}
#[cfg(target_os = "fuchsia")]
pub struct EmulatorServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for EmulatorServiceProxy {
    type Service = EmulatorServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl EmulatorServiceProxy {
    pub fn connect_to_device(&self) -> Result<EmulatorProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<EmulatorMarker>();
        self.connect_channel_to_device(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_device`, but returns a sync proxy.
    /// See [`Self::connect_to_device`] for more details.
    pub fn connect_to_device_sync(&self) -> Result<EmulatorSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<EmulatorMarker>();
        self.connect_channel_to_device(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_device`, but accepts a server end.
    /// See [`Self::connect_to_device`] for more details.
    pub fn connect_channel_to_device(
        &self,
        server_end: fidl::endpoints::ServerEnd<EmulatorMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("device", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for HciServiceMarker {
    type Proxy = HciServiceProxy;
    type Request = HciServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.bluetooth.HciService";
}

/// A request for one of the member protocols of HciService.
///
/// Wrap the protocol in a service that will be exposed to the child driver.
#[cfg(target_os = "fuchsia")]
pub enum HciServiceRequest {
    Hci(HciRequestStream),
    HciTransport(HciTransportRequestStream),
    Snoop(SnoopRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for HciServiceRequest {
    type Service = HciServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "hci" => Self::Hci(<HciRequestStream as fidl::endpoints::RequestStream>::from_channel(
                _channel,
            )),
            "hci_transport" => Self::HciTransport(
                <HciTransportRequestStream as fidl::endpoints::RequestStream>::from_channel(
                    _channel,
                ),
            ),
            "snoop" => Self::Snoop(
                <SnoopRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            _ => panic!("no such member protocol name for service HciService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["hci", "hci_transport", "snoop"]
    }
}
/// Wrap the protocol in a service that will be exposed to the child driver.
#[cfg(target_os = "fuchsia")]
pub struct HciServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for HciServiceProxy {
    type Service = HciServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl HciServiceProxy {
    pub fn connect_to_hci(&self) -> Result<HciProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<HciMarker>();
        self.connect_channel_to_hci(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_hci`, but returns a sync proxy.
    /// See [`Self::connect_to_hci`] for more details.
    pub fn connect_to_hci_sync(&self) -> Result<HciSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<HciMarker>();
        self.connect_channel_to_hci(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_hci`, but accepts a server end.
    /// See [`Self::connect_to_hci`] for more details.
    pub fn connect_channel_to_hci(
        &self,
        server_end: fidl::endpoints::ServerEnd<HciMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("hci", server_end.into_channel())
    }
    pub fn connect_to_hci_transport(&self) -> Result<HciTransportProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<HciTransportMarker>();
        self.connect_channel_to_hci_transport(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_hci_transport`, but returns a sync proxy.
    /// See [`Self::connect_to_hci_transport`] for more details.
    pub fn connect_to_hci_transport_sync(
        &self,
    ) -> Result<HciTransportSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<HciTransportMarker>();
        self.connect_channel_to_hci_transport(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_hci_transport`, but accepts a server end.
    /// See [`Self::connect_to_hci_transport`] for more details.
    pub fn connect_channel_to_hci_transport(
        &self,
        server_end: fidl::endpoints::ServerEnd<HciTransportMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("hci_transport", server_end.into_channel())
    }
    pub fn connect_to_snoop(&self) -> Result<SnoopProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<SnoopMarker>();
        self.connect_channel_to_snoop(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_snoop`, but returns a sync proxy.
    /// See [`Self::connect_to_snoop`] for more details.
    pub fn connect_to_snoop_sync(&self) -> Result<SnoopSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<SnoopMarker>();
        self.connect_channel_to_snoop(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_snoop`, but accepts a server end.
    /// See [`Self::connect_to_snoop`] for more details.
    pub fn connect_channel_to_snoop(
        &self,
        server_end: fidl::endpoints::ServerEnd<SnoopMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("snoop", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for ServiceMarker {
    type Proxy = ServiceProxy;
    type Request = ServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.bluetooth.Service";
}

/// A request for one of the member protocols of Service.
///
#[cfg(target_os = "fuchsia")]
pub enum ServiceRequest {
    Vendor(VendorRequestStream),
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for ServiceRequest {
    type Service = ServiceMarker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "vendor" => Self::Vendor(
                <VendorRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            _ => panic!("no such member protocol name for service Service"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["vendor"]
    }
}
#[cfg(target_os = "fuchsia")]
pub struct ServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for ServiceProxy {
    type Service = ServiceMarker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl ServiceProxy {
    pub fn connect_to_vendor(&self) -> Result<VendorProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<VendorMarker>();
        self.connect_channel_to_vendor(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_vendor`, but returns a sync proxy.
    /// See [`Self::connect_to_vendor`] for more details.
    pub fn connect_to_vendor_sync(&self) -> Result<VendorSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<VendorMarker>();
        self.connect_channel_to_vendor(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_vendor`, but accepts a server end.
    /// See [`Self::connect_to_vendor`] for more details.
    pub fn connect_channel_to_vendor(
        &self,
        server_end: fidl::endpoints::ServerEnd<VendorMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("vendor", server_end.into_channel())
    }

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}

mod internal {
    use super::*;

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.channel, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.channel, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.channel, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.channel, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.channel, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for VendorOpenHciTransportResponse {
        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 VendorOpenHciTransportResponse {
        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<
            VendorOpenHciTransportResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut VendorOpenHciTransportResponse
    {
        #[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::<VendorOpenHciTransportResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<VendorOpenHciTransportResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<HciTransportMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.channel),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<HciTransportMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            VendorOpenHciTransportResponse,
            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::<VendorOpenHciTransportResponse>(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 VendorOpenHciTransportResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                channel: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<HciTransportMarker>>,
                    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::ClientEnd<HciTransportMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.channel,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for VendorOpenHciResponse {
        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 VendorOpenHciResponse {
        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<VendorOpenHciResponse, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut VendorOpenHciResponse
    {
        #[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::<VendorOpenHciResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<VendorOpenHciResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<HciMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.channel),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<HciMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<VendorOpenHciResponse, 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::<VendorOpenHciResponse>(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 VendorOpenHciResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                channel: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<HciMarker>>,
                    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::ClientEnd<HciMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.channel,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for VendorOpenSnoopResponse {
        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 VendorOpenSnoopResponse {
        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<
            VendorOpenSnoopResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut VendorOpenSnoopResponse
    {
        #[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::<VendorOpenSnoopResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<VendorOpenSnoopResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SnoopMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.channel),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SnoopMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            VendorOpenSnoopResponse,
            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::<VendorOpenSnoopResponse>(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 VendorOpenSnoopResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                channel: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SnoopMarker>>,
                    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::ClientEnd<SnoopMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.channel,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl HciTransportConfigureScoRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.connection {
                return 4;
            }
            if let Some(_) = self.sample_rate {
                return 3;
            }
            if let Some(_) = self.encoding {
                return 2;
            }
            if let Some(_) = self.coding_format {
                return 1;
            }
            0
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ScoConnectionMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.connection.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ScoConnectionMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

    impl PeerParameters {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.channel {
                return 3;
            }
            if let Some(_) = self.connectable {
                return 2;
            }
            if let Some(_) = self.address {
                return 1;
            }
            0
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PeerMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.channel.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PeerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

    impl VirtualControllerCreateLoopbackDeviceRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.uart_channel {
                return 1;
            }
            0
        }
    }

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

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

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

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.uart_channel.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::Channel,
                        { fidl::ObjectType::CHANNEL.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }
}