fidl_fuchsia_bluetooth_le/

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

#[derive(Debug, PartialEq)]
pub struct AdvertisedPeripheralOnConnectedRequest {
    pub peer: Peer,
    pub connection: fidl::endpoints::ClientEnd<ConnectionMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct CentralConnectPeripheralRequest {
    pub identifier: String,
    pub options: ConnectionOptions,
    pub gatt_client: fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt::ClientMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct CentralConnectRequest {
    pub id: fidl_fuchsia_bluetooth::PeerId,
    pub options: ConnectionOptions,
    pub handle: fidl::endpoints::ServerEnd<ConnectionMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct CentralScanRequest {
    pub options: ScanOptions,
    pub result_watcher: fidl::endpoints::ServerEnd<ScanResultWatcherMarker>,
}

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ConnectionRequestGattClientRequest {
    pub client: fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt2::ClientMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct PeripheralAdvertiseRequest {
    pub parameters: AdvertisingParameters,
    pub advertised_peripheral: fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct PeripheralOnPeerConnectedRequest {
    pub peer: Peer,
    pub connection: fidl::endpoints::ClientEnd<ConnectionMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct PeripheralStartAdvertisingRequest {
    pub parameters: AdvertisingParameters,
    pub handle: fidl::endpoints::ServerEnd<AdvertisingHandleMarker>,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct CentralCreateConnectedIsochronousGroupRequest {
    /// Required. Parameters for the CIG.
    pub cig_parameters: Option<CigParameters>,
    /// Required. At least one CIS must be included.
    pub cis_requested_parameters: Option<Vec<CisRequestedParameters>>,
    /// Required. ConnectedIsochronousGroup protocol to connect.
    pub cig: Option<fidl::endpoints::ServerEnd<ConnectedIsochronousGroupMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct ChannelListenerRegistryListenL2capRequest {
    /// Accepted parameters for the local side of the channel.
    pub parameters: Option<AcceptedChannelParameters>,
    /// The channel listener protocol to open.
    pub listener: Option<fidl::endpoints::ClientEnd<ChannelListenerMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct CisRequestedParameters {
    /// ID selected to uniquely identify a stream within a CIG. All `cis_id`s
    /// must be distinct within a single creation request.
    /// Required.
    pub cis_id: Option<u8>,
    /// The channel that will be used for operations on the stream.
    /// Required.
    pub connection_stream: Option<fidl::endpoints::ServerEnd<IsochronousStreamMarker>>,
    /// Maximum SDU size (central => peripheral). This is a function of the
    /// codec being used. Unidirectional streams should set the unused
    /// direction to 0.
    /// Optional. If not provided, a value of 0 will be used (unidirectional)
    pub max_sdu_size_outgoing: Option<u16>,
    /// Maximum SDU size (peripheral => central). This is a function of the
    /// codec being used. Unidirectional streams should set the unused
    /// direction to 0.
    /// Optional. If not provided, a value of 0 will be used (unidirectional)
    pub max_sdu_size_incoming: Option<u16>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct ConnectionAcceptCisRequest {
    /// Identifier of the CIG that contains the requested CIS. Required.
    pub cig_id: Option<u8>,
    /// Identifier of the requested CIS. Required.
    pub cis_id: Option<u8>,
    /// When the stream is established, the server will invoke
    /// IsochronousStream::OnCisEstablished() on this channel. Required.
    ///
    /// If the client end of this channel is closed, requests of the corresponding CIG/CIS
    /// combination will be rejected until/unless another call is made to AcceptCis() with
    /// the same CIG/CIS parameters.
    pub connection_stream: Option<fidl::endpoints::ServerEnd<IsochronousStreamMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct ConnectionConnectL2capRequest {
    /// Parameters for the local side of the channel.
    pub parameters: Option<fidl_fuchsia_bluetooth::ChannelParameters>,
    /// The channel protocol to open.
    pub channel: Option<fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth::ChannelMarker>>,
    /// The PSM of the remote side to connect to.
    pub psm: Option<u16>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

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

impl fidl::endpoints::ProtocolMarker for AdvertisedPeripheralMarker {
    type Proxy = AdvertisedPeripheralProxy;
    type RequestStream = AdvertisedPeripheralRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AdvertisedPeripheralSynchronousProxy;

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

pub trait AdvertisedPeripheralProxyInterface: Send + Sync {
    type OnConnectedResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#on_connected(
        &self,
        peer: &Peer,
        connection: fidl::endpoints::ClientEnd<ConnectionMarker>,
    ) -> Self::OnConnectedResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AdvertisedPeripheralSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AdvertisedPeripheralSynchronousProxy {
    type Proxy = AdvertisedPeripheralProxy;
    type Protocol = AdvertisedPeripheralMarker;

    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 AdvertisedPeripheralSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <AdvertisedPeripheralMarker 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<AdvertisedPeripheralEvent, fidl::Error> {
        AdvertisedPeripheralEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Called when a remote LE central connects to this peripheral when
    /// connectable advertising is enabled via
    /// [`fuchsia.bluetooth.le/Peripheral.Advertise`]. When this call is made,
    /// the system has paused advertising, and will not continue until it
    /// receives a response.
    ///
    /// The returned [`fuchsia.bluetooth.le/Connection`] protocol can be used to
    /// interact with the peer. It also represents a peripheral's ownership over
    /// the connection: the client can drop the protocol to request a
    /// disconnection. Similarly, the protocol is closed by the system to
    /// indicate that the connection to the peer has been lost.
    ///
    /// + request `peer` Information about the central that initiated the
    ///   connection.
    /// + request `connection` Represents the connection.
    /// - response An empty response should be sent to acknowledge the
    ///   connection and resume advertising (for flow control).
    pub fn r#on_connected(
        &self,
        mut peer: &Peer,
        mut connection: fidl::endpoints::ClientEnd<ConnectionMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<AdvertisedPeripheralOnConnectedRequest, fidl::encoding::EmptyPayload>(
                (peer, connection),
                0x607b7716457eb178,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AdvertisedPeripheralProxy {
    type Protocol = AdvertisedPeripheralMarker;

    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 AdvertisedPeripheralProxy {
    /// Create a new Proxy for fuchsia.bluetooth.le/AdvertisedPeripheral.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <AdvertisedPeripheralMarker 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) -> AdvertisedPeripheralEventStream {
        AdvertisedPeripheralEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Called when a remote LE central connects to this peripheral when
    /// connectable advertising is enabled via
    /// [`fuchsia.bluetooth.le/Peripheral.Advertise`]. When this call is made,
    /// the system has paused advertising, and will not continue until it
    /// receives a response.
    ///
    /// The returned [`fuchsia.bluetooth.le/Connection`] protocol can be used to
    /// interact with the peer. It also represents a peripheral's ownership over
    /// the connection: the client can drop the protocol to request a
    /// disconnection. Similarly, the protocol is closed by the system to
    /// indicate that the connection to the peer has been lost.
    ///
    /// + request `peer` Information about the central that initiated the
    ///   connection.
    /// + request `connection` Represents the connection.
    /// - response An empty response should be sent to acknowledge the
    ///   connection and resume advertising (for flow control).
    pub fn r#on_connected(
        &self,
        mut peer: &Peer,
        mut connection: fidl::endpoints::ClientEnd<ConnectionMarker>,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        AdvertisedPeripheralProxyInterface::r#on_connected(self, peer, connection)
    }
}

impl AdvertisedPeripheralProxyInterface for AdvertisedPeripheralProxy {
    type OnConnectedResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#on_connected(
        &self,
        mut peer: &Peer,
        mut connection: fidl::endpoints::ClientEnd<ConnectionMarker>,
    ) -> Self::OnConnectedResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x607b7716457eb178,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<AdvertisedPeripheralOnConnectedRequest, ()>(
            (peer, connection),
            0x607b7716457eb178,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for AdvertisedPeripheralRequestStream {
    type Protocol = AdvertisedPeripheralMarker;
    type ControlHandle = AdvertisedPeripheralControlHandle;

    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 {
        AdvertisedPeripheralControlHandle { 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 AdvertisedPeripheralRequestStream {
    type Item = Result<AdvertisedPeripheralRequest, 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 AdvertisedPeripheralRequestStream 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 {
                0x607b7716457eb178 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(AdvertisedPeripheralOnConnectedRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AdvertisedPeripheralOnConnectedRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AdvertisedPeripheralControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AdvertisedPeripheralRequest::OnConnected {peer: req.peer,
connection: req.connection,

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

/// Protocol that is valid for the duration of advertising. The caller can close
/// the protocol to stop advertising. If the system internally stops advertising
/// for any reason, the protocol will be closed to communicate this to the
/// client.
#[derive(Debug)]
pub enum AdvertisedPeripheralRequest {
    /// Called when a remote LE central connects to this peripheral when
    /// connectable advertising is enabled via
    /// [`fuchsia.bluetooth.le/Peripheral.Advertise`]. When this call is made,
    /// the system has paused advertising, and will not continue until it
    /// receives a response.
    ///
    /// The returned [`fuchsia.bluetooth.le/Connection`] protocol can be used to
    /// interact with the peer. It also represents a peripheral's ownership over
    /// the connection: the client can drop the protocol to request a
    /// disconnection. Similarly, the protocol is closed by the system to
    /// indicate that the connection to the peer has been lost.
    ///
    /// + request `peer` Information about the central that initiated the
    ///   connection.
    /// + request `connection` Represents the connection.
    /// - response An empty response should be sent to acknowledge the
    ///   connection and resume advertising (for flow control).
    OnConnected {
        peer: Peer,
        connection: fidl::endpoints::ClientEnd<ConnectionMarker>,
        responder: AdvertisedPeripheralOnConnectedResponder,
    },
}

impl AdvertisedPeripheralRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_connected(
        self,
    ) -> Option<(
        Peer,
        fidl::endpoints::ClientEnd<ConnectionMarker>,
        AdvertisedPeripheralOnConnectedResponder,
    )> {
        if let AdvertisedPeripheralRequest::OnConnected { peer, connection, responder } = self {
            Some((peer, connection, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for AdvertisingHandleMarker {
    type Proxy = AdvertisingHandleProxy;
    type RequestStream = AdvertisingHandleRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AdvertisingHandleSynchronousProxy;

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AdvertisingHandleSynchronousProxy {
    type Proxy = AdvertisingHandleProxy;
    type Protocol = AdvertisingHandleMarker;

    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 AdvertisingHandleSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <AdvertisingHandleMarker 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<AdvertisingHandleEvent, fidl::Error> {
        AdvertisingHandleEvent::decode(self.client.wait_for_event(deadline)?)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AdvertisingHandleProxy {
    type Protocol = AdvertisingHandleMarker;

    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 AdvertisingHandleProxy {
    /// Create a new Proxy for fuchsia.bluetooth.le/AdvertisingHandle.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <AdvertisingHandleMarker 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) -> AdvertisingHandleEventStream {
        AdvertisingHandleEventStream { event_receiver: self.client.take_event_receiver() }
    }
}

impl AdvertisingHandleProxyInterface for AdvertisingHandleProxy {}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for AdvertisingHandleRequestStream {
    type Protocol = AdvertisingHandleMarker;
    type ControlHandle = AdvertisingHandleControlHandle;

    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 {
        AdvertisingHandleControlHandle { 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 AdvertisingHandleRequestStream {
    type Item = Result<AdvertisingHandleRequest, 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 AdvertisingHandleRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <AdvertisingHandleMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Capability that is valid for the duration of advertising. The caller can close the handle to
/// stop advertising. If the system internally stops advertising for any reason, the handle will be
/// closed to communicate this to the client.
#[derive(Debug)]
pub enum AdvertisingHandleRequest {}

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

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

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

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

impl fidl::endpoints::ProtocolMarker for CentralMarker {
    type Proxy = CentralProxy;
    type RequestStream = CentralRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CentralSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.le.Central";
}
impl fidl::endpoints::DiscoverableProtocolMarker for CentralMarker {}
pub type CentralCreateConnectedIsochronousGroupResult =
    Result<CentralCreateConnectedIsochronousGroupResponse, CreateCigError>;

pub trait CentralProxyInterface: Send + Sync {
    type ListenL2capResponseFut: std::future::Future<Output = Result<ChannelListenerRegistryListenL2capResult, fidl::Error>>
        + Send;
    fn r#listen_l2cap(
        &self,
        payload: ChannelListenerRegistryListenL2capRequest,
    ) -> Self::ListenL2capResponseFut;
    type ScanResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#scan(
        &self,
        options: &ScanOptions,
        result_watcher: fidl::endpoints::ServerEnd<ScanResultWatcherMarker>,
    ) -> Self::ScanResponseFut;
    fn r#connect(
        &self,
        id: &fidl_fuchsia_bluetooth::PeerId,
        options: &ConnectionOptions,
        handle: fidl::endpoints::ServerEnd<ConnectionMarker>,
    ) -> Result<(), fidl::Error>;
    type CreateConnectedIsochronousGroupResponseFut: std::future::Future<
            Output = Result<CentralCreateConnectedIsochronousGroupResult, fidl::Error>,
        > + Send;
    fn r#create_connected_isochronous_group(
        &self,
        payload: CentralCreateConnectedIsochronousGroupRequest,
    ) -> Self::CreateConnectedIsochronousGroupResponseFut;
    type GetPeripheralsResponseFut: std::future::Future<Output = Result<Vec<RemoteDevice>, fidl::Error>>
        + Send;
    fn r#get_peripherals(
        &self,
        service_uuids: Option<&[String]>,
    ) -> Self::GetPeripheralsResponseFut;
    type GetPeripheralResponseFut: std::future::Future<Output = Result<Option<Box<RemoteDevice>>, fidl::Error>>
        + Send;
    fn r#get_peripheral(&self, identifier: &str) -> Self::GetPeripheralResponseFut;
    type StartScanResponseFut: std::future::Future<Output = Result<fidl_fuchsia_bluetooth::Status, fidl::Error>>
        + Send;
    fn r#start_scan(&self, filter: Option<&ScanFilter>) -> Self::StartScanResponseFut;
    fn r#stop_scan(&self) -> Result<(), fidl::Error>;
    type ConnectPeripheralResponseFut: std::future::Future<Output = Result<fidl_fuchsia_bluetooth::Status, fidl::Error>>
        + Send;
    fn r#connect_peripheral(
        &self,
        identifier: &str,
        options: &ConnectionOptions,
        gatt_client: fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt::ClientMarker>,
    ) -> Self::ConnectPeripheralResponseFut;
    type DisconnectPeripheralResponseFut: std::future::Future<Output = Result<fidl_fuchsia_bluetooth::Status, fidl::Error>>
        + Send;
    fn r#disconnect_peripheral(&self, identifier: &str) -> Self::DisconnectPeripheralResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CentralSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CentralSynchronousProxy {
    type Proxy = CentralProxy;
    type Protocol = CentralMarker;

    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 CentralSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <CentralMarker 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<CentralEvent, fidl::Error> {
        CentralEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Register a listener for incoming channels. The registry will assign a
    /// PSM value that is unique for the local device, as well as open a
    /// [`ChannelListener`] for accepting incoming channels. In the unlikely
    /// event that all PSMs have been assigned, this call will fail with
    /// `ZX_ERR_NO_RESOURCES`.
    ///
    /// Note that the method of service discovery or advertising is defined by
    /// the service or protocol, so it is the responsibility of the caller to
    /// communicate the assigned PSM to any clients.
    pub fn r#listen_l2cap(
        &self,
        mut payload: ChannelListenerRegistryListenL2capRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ChannelListenerRegistryListenL2capResult, fidl::Error> {
        let _response = self.client.send_query::<
            ChannelListenerRegistryListenL2capRequest,
            fidl::encoding::ResultType<ChannelListenerRegistryListenL2capResponse, i32>,
        >(
            &mut payload,
            0x39c6e9001d102338,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Scans for nearby LE peripherals and broadcasters. If the scan cannot be
    /// initiated, then `result_watcher` will be closed with an epitaph.
    ///
    /// A Central client is allowed to have only one active scan at a time.
    /// Accordingly, only one Scan request can be outstanding at a time.
    /// Additional calls to Scan will fail.
    ///
    /// The lifetime of the scan session is tied to the `result_watcher`
    /// protocol provided. The scan will be stopped if the channel is closed.
    ///
    /// Once a scan is started, the [`fuchsia.bluetooth.le/ScanResultWatcher`]
    /// can be used to watch for scan results.
    ///
    /// + request `options` Options used to configure the scan session.
    /// + request `result_watcher` Protocol that remains valid for the duration
    ///   of this scan session.
    /// - response An empty response will be sent to acknowledge the scan has
    ///   stopped.
    ///
    /// The following epitaphs may be sent by the server on error:
    /// * error `ALREADY_EXISTS`: A scan is already in progress. Each `Central`
    ///   protocol is only allowed 1 active scan.
    /// * error `INVALID_ARGS`: Some of the scan `options` are invalid. See the
    ///   `ScanOptions` documentation.
    /// * error `INTERNAL`: An internal error occurred and a scan could not be
    ///   started.
    pub fn r#scan(
        &self,
        mut options: &ScanOptions,
        mut result_watcher: fidl::endpoints::ServerEnd<ScanResultWatcherMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<CentralScanRequest, fidl::encoding::EmptyPayload>(
                (options, result_watcher),
                0x41f7121798dfe15f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Connect to the peer with the given identifier.
    ///
    /// The requested [`fuchsia.bluetooth.le/Connection`] represents the
    /// client's interest on the LE connection to the peer. Closing the channel
    /// removes interest, but may not result in disconnection if another client
    /// holds a valid [`fuchsia.bluetooth.le/Connection`] to the same peer.
    ///
    /// The [`fuchsia.bluetooth.le/Connection`] `handle` will be closed by the
    /// system if the connection to the peer is lost or an error occurs.
    ///
    /// The following epitaphs may be sent by the server on error:
    /// + `INVALID_ARGS`: Some of the parameters are invalid.
    /// + `ALREADY_BOUND`: A Connection to the peer already exists for this Central. The existing
    ///                    Connection should be used.
    /// + `NOT_CONNECTED`: A connection could not be established.
    /// + `CONNECTION_RESET`: The peer disconnected.
    ///
    /// + request `id` Identifier of the peer to initiate a connection to.
    /// + request `options` Options used to configure the connection.
    /// + request `handle` Handle that remains valid for the duration of this
    ///   connection.
    pub fn r#connect(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut options: &ConnectionOptions,
        mut handle: fidl::endpoints::ServerEnd<ConnectionMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<CentralConnectRequest>(
            (id, options, handle),
            0x31a3065f2a6913c4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Create a new Connected Iosochronous Group (CIG) with the specified parameters. This
    /// operation is only valid when operating in the Central role for a connection.
    ///
    /// If the Central channel is closed before the CIG is explicitly removed, the group will
    /// be removed and disconnected.
    ///
    /// On failure, returns an error code, see `CreateCigError`. On success, returns a unique
    /// id allocated by the host.
    pub fn r#create_connected_isochronous_group(
        &self,
        mut payload: CentralCreateConnectedIsochronousGroupRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CentralCreateConnectedIsochronousGroupResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<CentralCreateConnectedIsochronousGroupRequest, fidl::encoding::ResultType<
                CentralCreateConnectedIsochronousGroupResponse,
                CreateCigError,
            >>(
                &mut payload,
                0x60323e70ae22e13,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Returns the list of peripherals that are known to the system from previous scan, connection,
    /// and/or bonding procedures. The results can be filtered based on service UUIDs that are known to
    /// be present on the peripheral.
    ///
    /// This method only returns peripherals (i.e. connectable devices).
    pub fn r#get_peripherals(
        &self,
        mut service_uuids: Option<&[String]>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<RemoteDevice>, fidl::Error> {
        let _response =
            self.client.send_query::<CentralGetPeripheralsRequest, CentralGetPeripheralsResponse>(
                (service_uuids,),
                0x37ba777499c683a8,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.peripherals)
    }

    /// **This method is not implemented by the Fuchsia core stack- TODO(https://fxbug.dev/42087303)**
    ///
    /// Returns information about a single peripheral that is known to the system from previous scan,
    /// connection, and/or bonding procedures based on its unique identifier. Returns null if
    /// `identifier` is not recognized.
    pub fn r#get_peripheral(
        &self,
        mut identifier: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Option<Box<RemoteDevice>>, fidl::Error> {
        let _response =
            self.client.send_query::<CentralGetPeripheralRequest, CentralGetPeripheralResponse>(
                (identifier,),
                0x97f5a2f2d9c13da,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.peripheral)
    }

    /// Initiates a scan session for nearby peripherals and broadcasters. Discovered devices will be
    /// reported via CentralDelegate.OnDeviceDiscovered(). If a scan session is already in progress,
    /// `filter` will replace the existing session's filter.
    ///
    /// If `filter` is null or empty (i.e. none of its fields has been populated) then the delegate
    /// will be notified for all discoverable devices that are found. This is not recommended; clients
    /// should generally filter results by at least one of `filter.service_uuids`,
    /// `filter.service_data`, and/or `filter.manufacturer_identifier`.
    pub fn r#start_scan(
        &self,
        mut filter: Option<&ScanFilter>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
        let _response =
            self.client.send_query::<CentralStartScanRequest, CentralStartScanResponse>(
                (filter,),
                0xeb4cf0cd0e1132b,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Terminate a previously started scan session.
    pub fn r#stop_scan(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x5f79ee6a0bb037a0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Creates a connection to the peripheral device with the given identifier.
    /// Returns the status of the operation in `status`.
    ///
    /// On success, `gatt_client` will be bound and can be used for GATT client
    /// role procedures. On failure, `gatt_client` will be closed and `status` will
    /// indicate an error.
    pub fn r#connect_peripheral(
        &self,
        mut identifier: &str,
        mut options: &ConnectionOptions,
        mut gatt_client: fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt::ClientMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
        let _response = self
            .client
            .send_query::<CentralConnectPeripheralRequest, CentralConnectPeripheralResponse>(
                (identifier, options, gatt_client),
                0x714d6c32d066d75a,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Disconnects this Central's connection to the peripheral with the given identifier.
    pub fn r#disconnect_peripheral(
        &self,
        mut identifier: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
        let _response = self
            .client
            .send_query::<CentralDisconnectPeripheralRequest, CentralDisconnectPeripheralResponse>(
                (identifier,),
                0xa9430da197362fd,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for CentralProxy {
    type Protocol = CentralMarker;

    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 CentralProxy {
    /// Create a new Proxy for fuchsia.bluetooth.le/Central.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <CentralMarker 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) -> CentralEventStream {
        CentralEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Register a listener for incoming channels. The registry will assign a
    /// PSM value that is unique for the local device, as well as open a
    /// [`ChannelListener`] for accepting incoming channels. In the unlikely
    /// event that all PSMs have been assigned, this call will fail with
    /// `ZX_ERR_NO_RESOURCES`.
    ///
    /// Note that the method of service discovery or advertising is defined by
    /// the service or protocol, so it is the responsibility of the caller to
    /// communicate the assigned PSM to any clients.
    pub fn r#listen_l2cap(
        &self,
        mut payload: ChannelListenerRegistryListenL2capRequest,
    ) -> fidl::client::QueryResponseFut<
        ChannelListenerRegistryListenL2capResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CentralProxyInterface::r#listen_l2cap(self, payload)
    }

    /// Scans for nearby LE peripherals and broadcasters. If the scan cannot be
    /// initiated, then `result_watcher` will be closed with an epitaph.
    ///
    /// A Central client is allowed to have only one active scan at a time.
    /// Accordingly, only one Scan request can be outstanding at a time.
    /// Additional calls to Scan will fail.
    ///
    /// The lifetime of the scan session is tied to the `result_watcher`
    /// protocol provided. The scan will be stopped if the channel is closed.
    ///
    /// Once a scan is started, the [`fuchsia.bluetooth.le/ScanResultWatcher`]
    /// can be used to watch for scan results.
    ///
    /// + request `options` Options used to configure the scan session.
    /// + request `result_watcher` Protocol that remains valid for the duration
    ///   of this scan session.
    /// - response An empty response will be sent to acknowledge the scan has
    ///   stopped.
    ///
    /// The following epitaphs may be sent by the server on error:
    /// * error `ALREADY_EXISTS`: A scan is already in progress. Each `Central`
    ///   protocol is only allowed 1 active scan.
    /// * error `INVALID_ARGS`: Some of the scan `options` are invalid. See the
    ///   `ScanOptions` documentation.
    /// * error `INTERNAL`: An internal error occurred and a scan could not be
    ///   started.
    pub fn r#scan(
        &self,
        mut options: &ScanOptions,
        mut result_watcher: fidl::endpoints::ServerEnd<ScanResultWatcherMarker>,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        CentralProxyInterface::r#scan(self, options, result_watcher)
    }

    /// Connect to the peer with the given identifier.
    ///
    /// The requested [`fuchsia.bluetooth.le/Connection`] represents the
    /// client's interest on the LE connection to the peer. Closing the channel
    /// removes interest, but may not result in disconnection if another client
    /// holds a valid [`fuchsia.bluetooth.le/Connection`] to the same peer.
    ///
    /// The [`fuchsia.bluetooth.le/Connection`] `handle` will be closed by the
    /// system if the connection to the peer is lost or an error occurs.
    ///
    /// The following epitaphs may be sent by the server on error:
    /// + `INVALID_ARGS`: Some of the parameters are invalid.
    /// + `ALREADY_BOUND`: A Connection to the peer already exists for this Central. The existing
    ///                    Connection should be used.
    /// + `NOT_CONNECTED`: A connection could not be established.
    /// + `CONNECTION_RESET`: The peer disconnected.
    ///
    /// + request `id` Identifier of the peer to initiate a connection to.
    /// + request `options` Options used to configure the connection.
    /// + request `handle` Handle that remains valid for the duration of this
    ///   connection.
    pub fn r#connect(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut options: &ConnectionOptions,
        mut handle: fidl::endpoints::ServerEnd<ConnectionMarker>,
    ) -> Result<(), fidl::Error> {
        CentralProxyInterface::r#connect(self, id, options, handle)
    }

    /// Create a new Connected Iosochronous Group (CIG) with the specified parameters. This
    /// operation is only valid when operating in the Central role for a connection.
    ///
    /// If the Central channel is closed before the CIG is explicitly removed, the group will
    /// be removed and disconnected.
    ///
    /// On failure, returns an error code, see `CreateCigError`. On success, returns a unique
    /// id allocated by the host.
    pub fn r#create_connected_isochronous_group(
        &self,
        mut payload: CentralCreateConnectedIsochronousGroupRequest,
    ) -> fidl::client::QueryResponseFut<
        CentralCreateConnectedIsochronousGroupResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CentralProxyInterface::r#create_connected_isochronous_group(self, payload)
    }

    /// Returns the list of peripherals that are known to the system from previous scan, connection,
    /// and/or bonding procedures. The results can be filtered based on service UUIDs that are known to
    /// be present on the peripheral.
    ///
    /// This method only returns peripherals (i.e. connectable devices).
    pub fn r#get_peripherals(
        &self,
        mut service_uuids: Option<&[String]>,
    ) -> fidl::client::QueryResponseFut<
        Vec<RemoteDevice>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CentralProxyInterface::r#get_peripherals(self, service_uuids)
    }

    /// **This method is not implemented by the Fuchsia core stack- TODO(https://fxbug.dev/42087303)**
    ///
    /// Returns information about a single peripheral that is known to the system from previous scan,
    /// connection, and/or bonding procedures based on its unique identifier. Returns null if
    /// `identifier` is not recognized.
    pub fn r#get_peripheral(
        &self,
        mut identifier: &str,
    ) -> fidl::client::QueryResponseFut<
        Option<Box<RemoteDevice>>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CentralProxyInterface::r#get_peripheral(self, identifier)
    }

    /// Initiates a scan session for nearby peripherals and broadcasters. Discovered devices will be
    /// reported via CentralDelegate.OnDeviceDiscovered(). If a scan session is already in progress,
    /// `filter` will replace the existing session's filter.
    ///
    /// If `filter` is null or empty (i.e. none of its fields has been populated) then the delegate
    /// will be notified for all discoverable devices that are found. This is not recommended; clients
    /// should generally filter results by at least one of `filter.service_uuids`,
    /// `filter.service_data`, and/or `filter.manufacturer_identifier`.
    pub fn r#start_scan(
        &self,
        mut filter: Option<&ScanFilter>,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CentralProxyInterface::r#start_scan(self, filter)
    }

    /// Terminate a previously started scan session.
    pub fn r#stop_scan(&self) -> Result<(), fidl::Error> {
        CentralProxyInterface::r#stop_scan(self)
    }

    /// Creates a connection to the peripheral device with the given identifier.
    /// Returns the status of the operation in `status`.
    ///
    /// On success, `gatt_client` will be bound and can be used for GATT client
    /// role procedures. On failure, `gatt_client` will be closed and `status` will
    /// indicate an error.
    pub fn r#connect_peripheral(
        &self,
        mut identifier: &str,
        mut options: &ConnectionOptions,
        mut gatt_client: fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt::ClientMarker>,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CentralProxyInterface::r#connect_peripheral(self, identifier, options, gatt_client)
    }

    /// Disconnects this Central's connection to the peripheral with the given identifier.
    pub fn r#disconnect_peripheral(
        &self,
        mut identifier: &str,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CentralProxyInterface::r#disconnect_peripheral(self, identifier)
    }
}

impl CentralProxyInterface for CentralProxy {
    type ListenL2capResponseFut = fidl::client::QueryResponseFut<
        ChannelListenerRegistryListenL2capResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#listen_l2cap(
        &self,
        mut payload: ChannelListenerRegistryListenL2capRequest,
    ) -> Self::ListenL2capResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ChannelListenerRegistryListenL2capResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ChannelListenerRegistryListenL2capResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x39c6e9001d102338,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ChannelListenerRegistryListenL2capRequest,
            ChannelListenerRegistryListenL2capResult,
        >(
            &mut payload,
            0x39c6e9001d102338,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ScanResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#scan(
        &self,
        mut options: &ScanOptions,
        mut result_watcher: fidl::endpoints::ServerEnd<ScanResultWatcherMarker>,
    ) -> Self::ScanResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x41f7121798dfe15f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<CentralScanRequest, ()>(
            (options, result_watcher),
            0x41f7121798dfe15f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#connect(
        &self,
        mut id: &fidl_fuchsia_bluetooth::PeerId,
        mut options: &ConnectionOptions,
        mut handle: fidl::endpoints::ServerEnd<ConnectionMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<CentralConnectRequest>(
            (id, options, handle),
            0x31a3065f2a6913c4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type CreateConnectedIsochronousGroupResponseFut = fidl::client::QueryResponseFut<
        CentralCreateConnectedIsochronousGroupResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_connected_isochronous_group(
        &self,
        mut payload: CentralCreateConnectedIsochronousGroupRequest,
    ) -> Self::CreateConnectedIsochronousGroupResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CentralCreateConnectedIsochronousGroupResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    CentralCreateConnectedIsochronousGroupResponse,
                    CreateCigError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x60323e70ae22e13,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            CentralCreateConnectedIsochronousGroupRequest,
            CentralCreateConnectedIsochronousGroupResult,
        >(
            &mut payload,
            0x60323e70ae22e13,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPeripheralsResponseFut = fidl::client::QueryResponseFut<
        Vec<RemoteDevice>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_peripherals(
        &self,
        mut service_uuids: Option<&[String]>,
    ) -> Self::GetPeripheralsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<RemoteDevice>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CentralGetPeripheralsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x37ba777499c683a8,
            >(_buf?)?;
            Ok(_response.peripherals)
        }
        self.client.send_query_and_decode::<CentralGetPeripheralsRequest, Vec<RemoteDevice>>(
            (service_uuids,),
            0x37ba777499c683a8,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPeripheralResponseFut = fidl::client::QueryResponseFut<
        Option<Box<RemoteDevice>>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_peripheral(&self, mut identifier: &str) -> Self::GetPeripheralResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Option<Box<RemoteDevice>>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CentralGetPeripheralResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x97f5a2f2d9c13da,
            >(_buf?)?;
            Ok(_response.peripheral)
        }
        self.client.send_query_and_decode::<CentralGetPeripheralRequest, Option<Box<RemoteDevice>>>(
            (identifier,),
            0x97f5a2f2d9c13da,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartScanResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start_scan(&self, mut filter: Option<&ScanFilter>) -> Self::StartScanResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CentralStartScanResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xeb4cf0cd0e1132b,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client
            .send_query_and_decode::<CentralStartScanRequest, fidl_fuchsia_bluetooth::Status>(
                (filter,),
                0xeb4cf0cd0e1132b,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

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

    type ConnectPeripheralResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect_peripheral(
        &self,
        mut identifier: &str,
        mut options: &ConnectionOptions,
        mut gatt_client: fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt::ClientMarker>,
    ) -> Self::ConnectPeripheralResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CentralConnectPeripheralResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x714d6c32d066d75a,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<
            CentralConnectPeripheralRequest,
            fidl_fuchsia_bluetooth::Status,
        >(
            (identifier, options, gatt_client,),
            0x714d6c32d066d75a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DisconnectPeripheralResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_bluetooth::Status,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#disconnect_peripheral(
        &self,
        mut identifier: &str,
    ) -> Self::DisconnectPeripheralResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_bluetooth::Status, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CentralDisconnectPeripheralResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xa9430da197362fd,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<
            CentralDisconnectPeripheralRequest,
            fidl_fuchsia_bluetooth::Status,
        >(
            (identifier,),
            0xa9430da197362fd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum CentralEvent {
    OnScanStateChanged { scanning: bool },
    OnDeviceDiscovered { device: RemoteDevice },
    OnPeripheralDisconnected { identifier: String },
}

impl CentralEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_scan_state_changed(self) -> Option<bool> {
        if let CentralEvent::OnScanStateChanged { scanning } = self {
            Some((scanning))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_device_discovered(self) -> Option<RemoteDevice> {
        if let CentralEvent::OnDeviceDiscovered { device } = self {
            Some((device))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_peripheral_disconnected(self) -> Option<String> {
        if let CentralEvent::OnPeripheralDisconnected { identifier } = self {
            Some((identifier))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`CentralEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<CentralEvent, 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 {
            0x5f8edc23cad04d3f => {
                let mut out = fidl::new_empty!(
                    CentralOnScanStateChangedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CentralOnScanStateChangedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((CentralEvent::OnScanStateChanged { scanning: out.scanning }))
            }
            0x708dadf20d66db6 => {
                let mut out = fidl::new_empty!(
                    CentralOnDeviceDiscoveredRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CentralOnDeviceDiscoveredRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((CentralEvent::OnDeviceDiscovered { device: out.device }))
            }
            0x4e4c6b979b2126df => {
                let mut out = fidl::new_empty!(
                    CentralOnPeripheralDisconnectedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CentralOnPeripheralDisconnectedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((CentralEvent::OnPeripheralDisconnected { identifier: out.identifier }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <CentralMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for CentralRequestStream {
    type Protocol = CentralMarker;
    type ControlHandle = CentralControlHandle;

    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 {
        CentralControlHandle { 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 CentralRequestStream {
    type Item = Result<CentralRequest, 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 CentralRequestStream 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 {
                    0x39c6e9001d102338 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ChannelListenerRegistryListenL2capRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelListenerRegistryListenL2capRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CentralControlHandle { inner: this.inner.clone() };
                        Ok(CentralRequest::ListenL2cap {
                            payload: req,
                            responder: CentralListenL2capResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x41f7121798dfe15f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CentralScanRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CentralScanRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CentralControlHandle { inner: this.inner.clone() };
                        Ok(CentralRequest::Scan {
                            options: req.options,
                            result_watcher: req.result_watcher,

                            responder: CentralScanResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x31a3065f2a6913c4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            CentralConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CentralConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CentralControlHandle { inner: this.inner.clone() };
                        Ok(CentralRequest::Connect {
                            id: req.id,
                            options: req.options,
                            handle: req.handle,

                            control_handle,
                        })
                    }
                    0x60323e70ae22e13 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CentralCreateConnectedIsochronousGroupRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CentralCreateConnectedIsochronousGroupRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CentralControlHandle { inner: this.inner.clone() };
                        Ok(CentralRequest::CreateConnectedIsochronousGroup {
                            payload: req,
                            responder: CentralCreateConnectedIsochronousGroupResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x37ba777499c683a8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CentralGetPeripheralsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CentralGetPeripheralsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CentralControlHandle { inner: this.inner.clone() };
                        Ok(CentralRequest::GetPeripherals {
                            service_uuids: req.service_uuids,

                            responder: CentralGetPeripheralsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x97f5a2f2d9c13da => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CentralGetPeripheralRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CentralGetPeripheralRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CentralControlHandle { inner: this.inner.clone() };
                        Ok(CentralRequest::GetPeripheral {
                            identifier: req.identifier,

                            responder: CentralGetPeripheralResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xeb4cf0cd0e1132b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CentralStartScanRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CentralStartScanRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CentralControlHandle { inner: this.inner.clone() };
                        Ok(CentralRequest::StartScan {
                            filter: req.filter,

                            responder: CentralStartScanResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5f79ee6a0bb037a0 => {
                        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 = CentralControlHandle { inner: this.inner.clone() };
                        Ok(CentralRequest::StopScan { control_handle })
                    }
                    0x714d6c32d066d75a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CentralConnectPeripheralRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CentralConnectPeripheralRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CentralControlHandle { inner: this.inner.clone() };
                        Ok(CentralRequest::ConnectPeripheral {
                            identifier: req.identifier,
                            options: req.options,
                            gatt_client: req.gatt_client,

                            responder: CentralConnectPeripheralResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xa9430da197362fd => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CentralDisconnectPeripheralRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CentralDisconnectPeripheralRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CentralControlHandle { inner: this.inner.clone() };
                        Ok(CentralRequest::DisconnectPeripheral {
                            identifier: req.identifier,

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

#[derive(Debug)]
pub enum CentralRequest {
    /// Register a listener for incoming channels. The registry will assign a
    /// PSM value that is unique for the local device, as well as open a
    /// [`ChannelListener`] for accepting incoming channels. In the unlikely
    /// event that all PSMs have been assigned, this call will fail with
    /// `ZX_ERR_NO_RESOURCES`.
    ///
    /// Note that the method of service discovery or advertising is defined by
    /// the service or protocol, so it is the responsibility of the caller to
    /// communicate the assigned PSM to any clients.
    ListenL2cap {
        payload: ChannelListenerRegistryListenL2capRequest,
        responder: CentralListenL2capResponder,
    },
    /// Scans for nearby LE peripherals and broadcasters. If the scan cannot be
    /// initiated, then `result_watcher` will be closed with an epitaph.
    ///
    /// A Central client is allowed to have only one active scan at a time.
    /// Accordingly, only one Scan request can be outstanding at a time.
    /// Additional calls to Scan will fail.
    ///
    /// The lifetime of the scan session is tied to the `result_watcher`
    /// protocol provided. The scan will be stopped if the channel is closed.
    ///
    /// Once a scan is started, the [`fuchsia.bluetooth.le/ScanResultWatcher`]
    /// can be used to watch for scan results.
    ///
    /// + request `options` Options used to configure the scan session.
    /// + request `result_watcher` Protocol that remains valid for the duration
    ///   of this scan session.
    /// - response An empty response will be sent to acknowledge the scan has
    ///   stopped.
    ///
    /// The following epitaphs may be sent by the server on error:
    /// * error `ALREADY_EXISTS`: A scan is already in progress. Each `Central`
    ///   protocol is only allowed 1 active scan.
    /// * error `INVALID_ARGS`: Some of the scan `options` are invalid. See the
    ///   `ScanOptions` documentation.
    /// * error `INTERNAL`: An internal error occurred and a scan could not be
    ///   started.
    Scan {
        options: ScanOptions,
        result_watcher: fidl::endpoints::ServerEnd<ScanResultWatcherMarker>,
        responder: CentralScanResponder,
    },
    /// Connect to the peer with the given identifier.
    ///
    /// The requested [`fuchsia.bluetooth.le/Connection`] represents the
    /// client's interest on the LE connection to the peer. Closing the channel
    /// removes interest, but may not result in disconnection if another client
    /// holds a valid [`fuchsia.bluetooth.le/Connection`] to the same peer.
    ///
    /// The [`fuchsia.bluetooth.le/Connection`] `handle` will be closed by the
    /// system if the connection to the peer is lost or an error occurs.
    ///
    /// The following epitaphs may be sent by the server on error:
    /// + `INVALID_ARGS`: Some of the parameters are invalid.
    /// + `ALREADY_BOUND`: A Connection to the peer already exists for this Central. The existing
    ///                    Connection should be used.
    /// + `NOT_CONNECTED`: A connection could not be established.
    /// + `CONNECTION_RESET`: The peer disconnected.
    ///
    /// + request `id` Identifier of the peer to initiate a connection to.
    /// + request `options` Options used to configure the connection.
    /// + request `handle` Handle that remains valid for the duration of this
    ///   connection.
    Connect {
        id: fidl_fuchsia_bluetooth::PeerId,
        options: ConnectionOptions,
        handle: fidl::endpoints::ServerEnd<ConnectionMarker>,
        control_handle: CentralControlHandle,
    },
    /// Create a new Connected Iosochronous Group (CIG) with the specified parameters. This
    /// operation is only valid when operating in the Central role for a connection.
    ///
    /// If the Central channel is closed before the CIG is explicitly removed, the group will
    /// be removed and disconnected.
    ///
    /// On failure, returns an error code, see `CreateCigError`. On success, returns a unique
    /// id allocated by the host.
    CreateConnectedIsochronousGroup {
        payload: CentralCreateConnectedIsochronousGroupRequest,
        responder: CentralCreateConnectedIsochronousGroupResponder,
    },
    /// Returns the list of peripherals that are known to the system from previous scan, connection,
    /// and/or bonding procedures. The results can be filtered based on service UUIDs that are known to
    /// be present on the peripheral.
    ///
    /// This method only returns peripherals (i.e. connectable devices).
    GetPeripherals { service_uuids: Option<Vec<String>>, responder: CentralGetPeripheralsResponder },
    /// **This method is not implemented by the Fuchsia core stack- TODO(https://fxbug.dev/42087303)**
    ///
    /// Returns information about a single peripheral that is known to the system from previous scan,
    /// connection, and/or bonding procedures based on its unique identifier. Returns null if
    /// `identifier` is not recognized.
    GetPeripheral { identifier: String, responder: CentralGetPeripheralResponder },
    /// Initiates a scan session for nearby peripherals and broadcasters. Discovered devices will be
    /// reported via CentralDelegate.OnDeviceDiscovered(). If a scan session is already in progress,
    /// `filter` will replace the existing session's filter.
    ///
    /// If `filter` is null or empty (i.e. none of its fields has been populated) then the delegate
    /// will be notified for all discoverable devices that are found. This is not recommended; clients
    /// should generally filter results by at least one of `filter.service_uuids`,
    /// `filter.service_data`, and/or `filter.manufacturer_identifier`.
    StartScan { filter: Option<Box<ScanFilter>>, responder: CentralStartScanResponder },
    /// Terminate a previously started scan session.
    StopScan { control_handle: CentralControlHandle },
    /// Creates a connection to the peripheral device with the given identifier.
    /// Returns the status of the operation in `status`.
    ///
    /// On success, `gatt_client` will be bound and can be used for GATT client
    /// role procedures. On failure, `gatt_client` will be closed and `status` will
    /// indicate an error.
    ConnectPeripheral {
        identifier: String,
        options: ConnectionOptions,
        gatt_client: fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt::ClientMarker>,
        responder: CentralConnectPeripheralResponder,
    },
    /// Disconnects this Central's connection to the peripheral with the given identifier.
    DisconnectPeripheral { identifier: String, responder: CentralDisconnectPeripheralResponder },
}

impl CentralRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_listen_l2cap(
        self,
    ) -> Option<(ChannelListenerRegistryListenL2capRequest, CentralListenL2capResponder)> {
        if let CentralRequest::ListenL2cap { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_scan(
        self,
    ) -> Option<(
        ScanOptions,
        fidl::endpoints::ServerEnd<ScanResultWatcherMarker>,
        CentralScanResponder,
    )> {
        if let CentralRequest::Scan { options, result_watcher, responder } = self {
            Some((options, result_watcher, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(
        fidl_fuchsia_bluetooth::PeerId,
        ConnectionOptions,
        fidl::endpoints::ServerEnd<ConnectionMarker>,
        CentralControlHandle,
    )> {
        if let CentralRequest::Connect { id, options, handle, control_handle } = self {
            Some((id, options, handle, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_connected_isochronous_group(
        self,
    ) -> Option<(
        CentralCreateConnectedIsochronousGroupRequest,
        CentralCreateConnectedIsochronousGroupResponder,
    )> {
        if let CentralRequest::CreateConnectedIsochronousGroup { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_peripherals(
        self,
    ) -> Option<(Option<Vec<String>>, CentralGetPeripheralsResponder)> {
        if let CentralRequest::GetPeripherals { service_uuids, responder } = self {
            Some((service_uuids, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_peripheral(self) -> Option<(String, CentralGetPeripheralResponder)> {
        if let CentralRequest::GetPeripheral { identifier, responder } = self {
            Some((identifier, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start_scan(self) -> Option<(Option<Box<ScanFilter>>, CentralStartScanResponder)> {
        if let CentralRequest::StartScan { filter, responder } = self {
            Some((filter, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_scan(self) -> Option<(CentralControlHandle)> {
        if let CentralRequest::StopScan { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_peripheral(
        self,
    ) -> Option<(
        String,
        ConnectionOptions,
        fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt::ClientMarker>,
        CentralConnectPeripheralResponder,
    )> {
        if let CentralRequest::ConnectPeripheral { identifier, options, gatt_client, responder } =
            self
        {
            Some((identifier, options, gatt_client, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_disconnect_peripheral(
        self,
    ) -> Option<(String, CentralDisconnectPeripheralResponder)> {
        if let CentralRequest::DisconnectPeripheral { identifier, responder } = self {
            Some((identifier, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            CentralRequest::ListenL2cap { .. } => "listen_l2cap",
            CentralRequest::Scan { .. } => "scan",
            CentralRequest::Connect { .. } => "connect",
            CentralRequest::CreateConnectedIsochronousGroup { .. } => {
                "create_connected_isochronous_group"
            }
            CentralRequest::GetPeripherals { .. } => "get_peripherals",
            CentralRequest::GetPeripheral { .. } => "get_peripheral",
            CentralRequest::StartScan { .. } => "start_scan",
            CentralRequest::StopScan { .. } => "stop_scan",
            CentralRequest::ConnectPeripheral { .. } => "connect_peripheral",
            CentralRequest::DisconnectPeripheral { .. } => "disconnect_peripheral",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for CentralControlHandle {
    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 CentralControlHandle {
    pub fn send_on_scan_state_changed(&self, mut scanning: bool) -> Result<(), fidl::Error> {
        self.inner.send::<CentralOnScanStateChangedRequest>(
            (scanning,),
            0,
            0x5f8edc23cad04d3f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_device_discovered(&self, mut device: &RemoteDevice) -> Result<(), fidl::Error> {
        self.inner.send::<CentralOnDeviceDiscoveredRequest>(
            (device,),
            0,
            0x708dadf20d66db6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_peripheral_disconnected(&self, mut identifier: &str) -> Result<(), fidl::Error> {
        self.inner.send::<CentralOnPeripheralDisconnectedRequest>(
            (identifier,),
            0,
            0x4e4c6b979b2126df,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut peripherals: &[RemoteDevice]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<CentralGetPeripheralsResponse>(
            (peripherals,),
            self.tx_id,
            0x37ba777499c683a8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut peripheral: Option<&RemoteDevice>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<CentralGetPeripheralResponse>(
            (peripheral,),
            self.tx_id,
            0x97f5a2f2d9c13da,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut status: &fidl_fuchsia_bluetooth::Status) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<CentralStartScanResponse>(
            (status,),
            self.tx_id,
            0xeb4cf0cd0e1132b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut status: &fidl_fuchsia_bluetooth::Status) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<CentralConnectPeripheralResponse>(
            (status,),
            self.tx_id,
            0x714d6c32d066d75a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut status: &fidl_fuchsia_bluetooth::Status) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<CentralDisconnectPeripheralResponse>(
            (status,),
            self.tx_id,
            0xa9430da197362fd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for ChannelListenerMarker {
    type Proxy = ChannelListenerProxy;
    type RequestStream = ChannelListenerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ChannelListenerSynchronousProxy;

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

pub trait ChannelListenerProxyInterface: Send + Sync {
    type AcceptResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#accept(
        &self,
        channel: fidl::endpoints::ClientEnd<fidl_fuchsia_bluetooth::ChannelMarker>,
    ) -> Self::AcceptResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ChannelListenerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ChannelListenerSynchronousProxy {
    type Proxy = ChannelListenerProxy;
    type Protocol = ChannelListenerMarker;

    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 ChannelListenerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ChannelListenerMarker 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<ChannelListenerEvent, fidl::Error> {
        ChannelListenerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    pub fn r#accept(
        &self,
        mut channel: fidl::endpoints::ClientEnd<fidl_fuchsia_bluetooth::ChannelMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            ChannelListenerAcceptRequest,
            fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
        >(
            (channel,),
            0x6f535bd36b20fc7b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ChannelListenerMarker>("accept")?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ChannelListenerProxy {
    type Protocol = ChannelListenerMarker;

    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 ChannelListenerProxy {
    /// Create a new Proxy for fuchsia.bluetooth.le/ChannelListener.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ChannelListenerMarker 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) -> ChannelListenerEventStream {
        ChannelListenerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#accept(
        &self,
        mut channel: fidl::endpoints::ClientEnd<fidl_fuchsia_bluetooth::ChannelMarker>,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        ChannelListenerProxyInterface::r#accept(self, channel)
    }
}

impl ChannelListenerProxyInterface for ChannelListenerProxy {
    type AcceptResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#accept(
        &self,
        mut channel: fidl::endpoints::ClientEnd<fidl_fuchsia_bluetooth::ChannelMarker>,
    ) -> Self::AcceptResponseFut {
        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,
                0x6f535bd36b20fc7b,
            >(_buf?)?
            .into_result::<ChannelListenerMarker>("accept")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<ChannelListenerAcceptRequest, ()>(
            (channel,),
            0x6f535bd36b20fc7b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ChannelListenerRequestStream {
    type Protocol = ChannelListenerMarker;
    type ControlHandle = ChannelListenerControlHandle;

    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 {
        ChannelListenerControlHandle { 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 ChannelListenerRequestStream {
    type Item = Result<ChannelListenerRequest, 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 ChannelListenerRequestStream 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 {
                    0x6f535bd36b20fc7b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ChannelListenerAcceptRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelListenerAcceptRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ChannelListenerControlHandle { inner: this.inner.clone() };
                        Ok(ChannelListenerRequest::Accept {
                            channel: req.channel,

                            responder: ChannelListenerAcceptResponder {
                                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(ChannelListenerRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ChannelListenerControlHandle {
                                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(ChannelListenerRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ChannelListenerControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ChannelListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Represents a service or protocol that accepts incoming channel requests.
/// Incoming channel requests for the associated PSM will be connected via this
/// protocol. Closing this protocol will also cease accepting any incoming
/// channel requests, but existing established channels will not be affected.
/// Additionally, once this protocol is closed the implementation is free to
/// reuse the PSM that was previously assigned for this instance.
#[derive(Debug)]
pub enum ChannelListenerRequest {
    Accept {
        channel: fidl::endpoints::ClientEnd<fidl_fuchsia_bluetooth::ChannelMarker>,
        responder: ChannelListenerAcceptResponder,
    },
    /// 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: ChannelListenerControlHandle,
        method_type: fidl::MethodType,
    },
}

impl ChannelListenerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_accept(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<fidl_fuchsia_bluetooth::ChannelMarker>,
        ChannelListenerAcceptResponder,
    )> {
        if let ChannelListenerRequest::Accept { channel, responder } = self {
            Some((channel, responder))
        } else {
            None
        }
    }

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

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

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

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

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

    fn control_handle(&self) -> &ChannelListenerControlHandle {
        &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 ChannelListenerAcceptResponder {
    /// 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,
            0x6f535bd36b20fc7b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for ChannelListenerRegistryMarker {
    type Proxy = ChannelListenerRegistryProxy;
    type RequestStream = ChannelListenerRegistryRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ChannelListenerRegistrySynchronousProxy;

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

pub trait ChannelListenerRegistryProxyInterface: Send + Sync {
    type ListenL2capResponseFut: std::future::Future<Output = Result<ChannelListenerRegistryListenL2capResult, fidl::Error>>
        + Send;
    fn r#listen_l2cap(
        &self,
        payload: ChannelListenerRegistryListenL2capRequest,
    ) -> Self::ListenL2capResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ChannelListenerRegistrySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ChannelListenerRegistrySynchronousProxy {
    type Proxy = ChannelListenerRegistryProxy;
    type Protocol = ChannelListenerRegistryMarker;

    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 ChannelListenerRegistrySynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <ChannelListenerRegistryMarker 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<ChannelListenerRegistryEvent, fidl::Error> {
        ChannelListenerRegistryEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Register a listener for incoming channels. The registry will assign a
    /// PSM value that is unique for the local device, as well as open a
    /// [`ChannelListener`] for accepting incoming channels. In the unlikely
    /// event that all PSMs have been assigned, this call will fail with
    /// `ZX_ERR_NO_RESOURCES`.
    ///
    /// Note that the method of service discovery or advertising is defined by
    /// the service or protocol, so it is the responsibility of the caller to
    /// communicate the assigned PSM to any clients.
    pub fn r#listen_l2cap(
        &self,
        mut payload: ChannelListenerRegistryListenL2capRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ChannelListenerRegistryListenL2capResult, fidl::Error> {
        let _response = self.client.send_query::<
            ChannelListenerRegistryListenL2capRequest,
            fidl::encoding::ResultType<ChannelListenerRegistryListenL2capResponse, i32>,
        >(
            &mut payload,
            0x39c6e9001d102338,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ChannelListenerRegistryProxy {
    type Protocol = ChannelListenerRegistryMarker;

    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 ChannelListenerRegistryProxy {
    /// Create a new Proxy for fuchsia.bluetooth.le/ChannelListenerRegistry.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <ChannelListenerRegistryMarker 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) -> ChannelListenerRegistryEventStream {
        ChannelListenerRegistryEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Register a listener for incoming channels. The registry will assign a
    /// PSM value that is unique for the local device, as well as open a
    /// [`ChannelListener`] for accepting incoming channels. In the unlikely
    /// event that all PSMs have been assigned, this call will fail with
    /// `ZX_ERR_NO_RESOURCES`.
    ///
    /// Note that the method of service discovery or advertising is defined by
    /// the service or protocol, so it is the responsibility of the caller to
    /// communicate the assigned PSM to any clients.
    pub fn r#listen_l2cap(
        &self,
        mut payload: ChannelListenerRegistryListenL2capRequest,
    ) -> fidl::client::QueryResponseFut<
        ChannelListenerRegistryListenL2capResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ChannelListenerRegistryProxyInterface::r#listen_l2cap(self, payload)
    }
}

impl ChannelListenerRegistryProxyInterface for ChannelListenerRegistryProxy {
    type ListenL2capResponseFut = fidl::client::QueryResponseFut<
        ChannelListenerRegistryListenL2capResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#listen_l2cap(
        &self,
        mut payload: ChannelListenerRegistryListenL2capRequest,
    ) -> Self::ListenL2capResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ChannelListenerRegistryListenL2capResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ChannelListenerRegistryListenL2capResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x39c6e9001d102338,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ChannelListenerRegistryListenL2capRequest,
            ChannelListenerRegistryListenL2capResult,
        >(
            &mut payload,
            0x39c6e9001d102338,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ChannelListenerRegistryRequestStream {
    type Protocol = ChannelListenerRegistryMarker;
    type ControlHandle = ChannelListenerRegistryControlHandle;

    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 {
        ChannelListenerRegistryControlHandle { 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 ChannelListenerRegistryRequestStream {
    type Item = Result<ChannelListenerRegistryRequest, 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 ChannelListenerRegistryRequestStream 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 {
                0x39c6e9001d102338 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(ChannelListenerRegistryListenL2capRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelListenerRegistryListenL2capRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = ChannelListenerRegistryControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ChannelListenerRegistryRequest::ListenL2cap {payload: req,
                        responder: ChannelListenerRegistryListenL2capResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <ChannelListenerRegistryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Represents the ability to register and accept incoming connections on
/// connection oriented channels.
#[derive(Debug)]
pub enum ChannelListenerRegistryRequest {
    /// Register a listener for incoming channels. The registry will assign a
    /// PSM value that is unique for the local device, as well as open a
    /// [`ChannelListener`] for accepting incoming channels. In the unlikely
    /// event that all PSMs have been assigned, this call will fail with
    /// `ZX_ERR_NO_RESOURCES`.
    ///
    /// Note that the method of service discovery or advertising is defined by
    /// the service or protocol, so it is the responsibility of the caller to
    /// communicate the assigned PSM to any clients.
    ListenL2cap {
        payload: ChannelListenerRegistryListenL2capRequest,
        responder: ChannelListenerRegistryListenL2capResponder,
    },
}

impl ChannelListenerRegistryRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_listen_l2cap(
        self,
    ) -> Option<(
        ChannelListenerRegistryListenL2capRequest,
        ChannelListenerRegistryListenL2capResponder,
    )> {
        if let ChannelListenerRegistryRequest::ListenL2cap { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for CodecDelayMarker {
    type Proxy = CodecDelayProxy;
    type RequestStream = CodecDelayRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CodecDelaySynchronousProxy;

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

pub trait CodecDelayProxyInterface: Send + Sync {
    type GetCodecLocalDelayRangeResponseFut: std::future::Future<Output = Result<CodecDelayGetCodecLocalDelayRangeResult, fidl::Error>>
        + Send;
    fn r#get_codec_local_delay_range(
        &self,
        payload: &CodecDelayGetCodecLocalDelayRangeRequest,
    ) -> Self::GetCodecLocalDelayRangeResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CodecDelaySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CodecDelaySynchronousProxy {
    type Proxy = CodecDelayProxy;
    type Protocol = CodecDelayMarker;

    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 CodecDelaySynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <CodecDelayMarker 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<CodecDelayEvent, fidl::Error> {
        CodecDelayEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Retrieve the range of controller delay for the codec specified with the provided stream
    /// attributes.
    ///
    /// On success, returns the minimum and maximum allowed delay.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if reading the delay is not supported.
    /// Returns ZX_ERR_INTERNAL for all other failures.
    pub fn r#get_codec_local_delay_range(
        &self,
        mut payload: &CodecDelayGetCodecLocalDelayRangeRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CodecDelayGetCodecLocalDelayRangeResult, fidl::Error> {
        let _response = self.client.send_query::<
            CodecDelayGetCodecLocalDelayRangeRequest,
            fidl::encoding::ResultType<CodecDelayGetCodecLocalDelayRangeResponse, i32>,
        >(
            payload,
            0x1cf34fdeed80b4d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for CodecDelayProxy {
    type Protocol = CodecDelayMarker;

    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 CodecDelayProxy {
    /// Create a new Proxy for fuchsia.bluetooth.le/CodecDelay.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <CodecDelayMarker 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) -> CodecDelayEventStream {
        CodecDelayEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Retrieve the range of controller delay for the codec specified with the provided stream
    /// attributes.
    ///
    /// On success, returns the minimum and maximum allowed delay.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if reading the delay is not supported.
    /// Returns ZX_ERR_INTERNAL for all other failures.
    pub fn r#get_codec_local_delay_range(
        &self,
        mut payload: &CodecDelayGetCodecLocalDelayRangeRequest,
    ) -> fidl::client::QueryResponseFut<
        CodecDelayGetCodecLocalDelayRangeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        CodecDelayProxyInterface::r#get_codec_local_delay_range(self, payload)
    }
}

impl CodecDelayProxyInterface for CodecDelayProxy {
    type GetCodecLocalDelayRangeResponseFut = fidl::client::QueryResponseFut<
        CodecDelayGetCodecLocalDelayRangeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_codec_local_delay_range(
        &self,
        mut payload: &CodecDelayGetCodecLocalDelayRangeRequest,
    ) -> Self::GetCodecLocalDelayRangeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CodecDelayGetCodecLocalDelayRangeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CodecDelayGetCodecLocalDelayRangeResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1cf34fdeed80b4d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            CodecDelayGetCodecLocalDelayRangeRequest,
            CodecDelayGetCodecLocalDelayRangeResult,
        >(
            payload,
            0x1cf34fdeed80b4d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for CodecDelayRequestStream {
    type Protocol = CodecDelayMarker;
    type ControlHandle = CodecDelayControlHandle;

    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 {
        CodecDelayControlHandle { 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 CodecDelayRequestStream {
    type Item = Result<CodecDelayRequest, 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 CodecDelayRequestStream 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 {
                    0x1cf34fdeed80b4d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CodecDelayGetCodecLocalDelayRangeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CodecDelayGetCodecLocalDelayRangeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = CodecDelayControlHandle { inner: this.inner.clone() };
                        Ok(CodecDelayRequest::GetCodecLocalDelayRange {
                            payload: req,
                            responder: CodecDelayGetCodecLocalDelayRangeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <CodecDelayMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// This protocol allows us to retrieve controller local delay values. It is not intended to be
/// used stand-alone, but to be composed into protocols that need access to this information.
#[derive(Debug)]
pub enum CodecDelayRequest {
    /// Retrieve the range of controller delay for the codec specified with the provided stream
    /// attributes.
    ///
    /// On success, returns the minimum and maximum allowed delay.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if reading the delay is not supported.
    /// Returns ZX_ERR_INTERNAL for all other failures.
    GetCodecLocalDelayRange {
        payload: CodecDelayGetCodecLocalDelayRangeRequest,
        responder: CodecDelayGetCodecLocalDelayRangeResponder,
    },
}

impl CodecDelayRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_codec_local_delay_range(
        self,
    ) -> Option<(
        CodecDelayGetCodecLocalDelayRangeRequest,
        CodecDelayGetCodecLocalDelayRangeResponder,
    )> {
        if let CodecDelayRequest::GetCodecLocalDelayRange { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ConnectedIsochronousGroupMarker {
    type Proxy = ConnectedIsochronousGroupProxy;
    type RequestStream = ConnectedIsochronousGroupRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ConnectedIsochronousGroupSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) ConnectedIsochronousGroup";
}
pub type ConnectedIsochronousGroupEstablishStreamsResult = Result<(), EstablishStreamsError>;

pub trait ConnectedIsochronousGroupProxyInterface: Send + Sync {
    type EstablishStreamsResponseFut: std::future::Future<
            Output = Result<ConnectedIsochronousGroupEstablishStreamsResult, fidl::Error>,
        > + Send;
    fn r#establish_streams(
        &self,
        payload: &ConnectedIsochronousGroupEstablishStreamsRequest,
    ) -> Self::EstablishStreamsResponseFut;
    fn r#remove(&self) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ConnectedIsochronousGroupSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ConnectedIsochronousGroupSynchronousProxy {
    type Proxy = ConnectedIsochronousGroupProxy;
    type Protocol = ConnectedIsochronousGroupMarker;

    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 ConnectedIsochronousGroupSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <ConnectedIsochronousGroupMarker 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<ConnectedIsochronousGroupEvent, fidl::Error> {
        ConnectedIsochronousGroupEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Connect one or more Isochronous streams. Each CIS is established with the peer specified
    /// in the parameters. On successful initiation of the operation, an OnEstablished() event will
    /// be sent on the IsochronousStream.
    ///
    /// On error, no CISes are established and an appropriate `EstablishStreamsError` code will be
    /// returned.
    ///
    /// Otherwise, this call returns once each CIS specified has connected.
    pub fn r#establish_streams(
        &self,
        mut payload: &ConnectedIsochronousGroupEstablishStreamsRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ConnectedIsochronousGroupEstablishStreamsResult, fidl::Error> {
        let _response = self.client.send_query::<
            ConnectedIsochronousGroupEstablishStreamsRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, EstablishStreamsError>,
        >(
            payload,
            0xc7296c5edb4dacc,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ConnectedIsochronousGroupMarker>("establish_streams")?;
        Ok(_response.map(|x| x))
    }

    /// Remove this CIG. Associated streams will be closed. This protocol will be closed after
    /// all of the associated streams have closed and the group has been removed.
    pub fn r#remove(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0xbed433babd20503,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ConnectedIsochronousGroupProxy {
    type Protocol = ConnectedIsochronousGroupMarker;

    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 ConnectedIsochronousGroupProxy {
    /// Create a new Proxy for fuchsia.bluetooth.le/ConnectedIsochronousGroup.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <ConnectedIsochronousGroupMarker 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) -> ConnectedIsochronousGroupEventStream {
        ConnectedIsochronousGroupEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connect one or more Isochronous streams. Each CIS is established with the peer specified
    /// in the parameters. On successful initiation of the operation, an OnEstablished() event will
    /// be sent on the IsochronousStream.
    ///
    /// On error, no CISes are established and an appropriate `EstablishStreamsError` code will be
    /// returned.
    ///
    /// Otherwise, this call returns once each CIS specified has connected.
    pub fn r#establish_streams(
        &self,
        mut payload: &ConnectedIsochronousGroupEstablishStreamsRequest,
    ) -> fidl::client::QueryResponseFut<
        ConnectedIsochronousGroupEstablishStreamsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ConnectedIsochronousGroupProxyInterface::r#establish_streams(self, payload)
    }

    /// Remove this CIG. Associated streams will be closed. This protocol will be closed after
    /// all of the associated streams have closed and the group has been removed.
    pub fn r#remove(&self) -> Result<(), fidl::Error> {
        ConnectedIsochronousGroupProxyInterface::r#remove(self)
    }
}

impl ConnectedIsochronousGroupProxyInterface for ConnectedIsochronousGroupProxy {
    type EstablishStreamsResponseFut = fidl::client::QueryResponseFut<
        ConnectedIsochronousGroupEstablishStreamsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#establish_streams(
        &self,
        mut payload: &ConnectedIsochronousGroupEstablishStreamsRequest,
    ) -> Self::EstablishStreamsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ConnectedIsochronousGroupEstablishStreamsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<
                    fidl::encoding::EmptyStruct,
                    EstablishStreamsError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xc7296c5edb4dacc,
            >(_buf?)?
            .into_result::<ConnectedIsochronousGroupMarker>("establish_streams")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ConnectedIsochronousGroupEstablishStreamsRequest,
            ConnectedIsochronousGroupEstablishStreamsResult,
        >(
            payload,
            0xc7296c5edb4dacc,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ConnectedIsochronousGroupRequestStream {
    type Protocol = ConnectedIsochronousGroupMarker;
    type ControlHandle = ConnectedIsochronousGroupControlHandle;

    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 {
        ConnectedIsochronousGroupControlHandle { 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 ConnectedIsochronousGroupRequestStream {
    type Item = Result<ConnectedIsochronousGroupRequest, 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 ConnectedIsochronousGroupRequestStream 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 {
                0xc7296c5edb4dacc => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(ConnectedIsochronousGroupEstablishStreamsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ConnectedIsochronousGroupEstablishStreamsRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = ConnectedIsochronousGroupControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ConnectedIsochronousGroupRequest::EstablishStreams {payload: req,
                        responder: ConnectedIsochronousGroupEstablishStreamsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0xbed433babd20503 => {
                    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 = ConnectedIsochronousGroupControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ConnectedIsochronousGroupRequest::Remove {
                        control_handle,
                    })
                }
                _ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                    Ok(ConnectedIsochronousGroupRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: ConnectedIsochronousGroupControlHandle { 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(ConnectedIsochronousGroupRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: ConnectedIsochronousGroupControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <ConnectedIsochronousGroupMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

#[derive(Debug)]
pub enum ConnectedIsochronousGroupRequest {
    /// Connect one or more Isochronous streams. Each CIS is established with the peer specified
    /// in the parameters. On successful initiation of the operation, an OnEstablished() event will
    /// be sent on the IsochronousStream.
    ///
    /// On error, no CISes are established and an appropriate `EstablishStreamsError` code will be
    /// returned.
    ///
    /// Otherwise, this call returns once each CIS specified has connected.
    EstablishStreams {
        payload: ConnectedIsochronousGroupEstablishStreamsRequest,
        responder: ConnectedIsochronousGroupEstablishStreamsResponder,
    },
    /// Remove this CIG. Associated streams will be closed. This protocol will be closed after
    /// all of the associated streams have closed and the group has been removed.
    Remove { control_handle: ConnectedIsochronousGroupControlHandle },
    /// 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: ConnectedIsochronousGroupControlHandle,
        method_type: fidl::MethodType,
    },
}

impl ConnectedIsochronousGroupRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_establish_streams(
        self,
    ) -> Option<(
        ConnectedIsochronousGroupEstablishStreamsRequest,
        ConnectedIsochronousGroupEstablishStreamsResponder,
    )> {
        if let ConnectedIsochronousGroupRequest::EstablishStreams { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove(self) -> Option<(ConnectedIsochronousGroupControlHandle)> {
        if let ConnectedIsochronousGroupRequest::Remove { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ConnectionMarker {
    type Proxy = ConnectionProxy;
    type RequestStream = ConnectionRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ConnectionSynchronousProxy;

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

pub trait ConnectionProxyInterface: Send + Sync {
    type GetCodecLocalDelayRangeResponseFut: std::future::Future<Output = Result<CodecDelayGetCodecLocalDelayRangeResult, fidl::Error>>
        + Send;
    fn r#get_codec_local_delay_range(
        &self,
        payload: &CodecDelayGetCodecLocalDelayRangeRequest,
    ) -> Self::GetCodecLocalDelayRangeResponseFut;
    fn r#request_gatt_client(
        &self,
        client: fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt2::ClientMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#accept_cis(&self, payload: ConnectionAcceptCisRequest) -> Result<(), fidl::Error>;
    fn r#connect_l2cap(&self, payload: ConnectionConnectL2capRequest) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ConnectionSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ConnectionSynchronousProxy {
    type Proxy = ConnectionProxy;
    type Protocol = ConnectionMarker;

    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 ConnectionSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ConnectionMarker 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<ConnectionEvent, fidl::Error> {
        ConnectionEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Retrieve the range of controller delay for the codec specified with the provided stream
    /// attributes.
    ///
    /// On success, returns the minimum and maximum allowed delay.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if reading the delay is not supported.
    /// Returns ZX_ERR_INTERNAL for all other failures.
    pub fn r#get_codec_local_delay_range(
        &self,
        mut payload: &CodecDelayGetCodecLocalDelayRangeRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<CodecDelayGetCodecLocalDelayRangeResult, fidl::Error> {
        let _response = self.client.send_query::<
            CodecDelayGetCodecLocalDelayRangeRequest,
            fidl::encoding::ResultType<CodecDelayGetCodecLocalDelayRangeResponse, i32>,
        >(
            payload,
            0x1cf34fdeed80b4d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// The following epitaphs may be sent by the server on error:
    /// + `ZX_ERR_ALREADY_BOUND`: A Client server has already been bound in this Connection
    ///                           protocol. The existing Client should be used.
    pub fn r#request_gatt_client(
        &self,
        mut client: fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt2::ClientMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ConnectionRequestGattClientRequest>(
            (client,),
            0x2a670e0fec6ccc6b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Accept a future CIS request from the peer with the specified CIG/CIS values. All
    /// CIS requests that have not explicitly been allowed will be rejected.
    ///
    /// The provided IsochronousStream will be used for future notification of established
    /// connections.
    ///
    /// The host may wait for multiple incoming connections simultaneously, although each
    /// must have a combination of CIG/CIS values that is unique to this connection.
    ///
    /// If we are not operating in the peripheral role in this connection, connection_stream
    /// will be closed with a ZX_ERR_NOT_SUPPORTED epitaph.
    ///
    /// If we are already waiting for another connection with the same combination of CIG/CIS
    /// values, connection_stream will be closed with a ZX_ERR_INVALID_ARGS epitaph.
    pub fn r#accept_cis(&self, mut payload: ConnectionAcceptCisRequest) -> Result<(), fidl::Error> {
        self.client.send::<ConnectionAcceptCisRequest>(
            &mut payload,
            0x7e6338c237088144,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Connect to an L2CAP LE connection-oriented channel.
    pub fn r#connect_l2cap(
        &self,
        mut payload: ConnectionConnectL2capRequest,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ConnectionConnectL2capRequest>(
            &mut payload,
            0x12351316feaebce9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ConnectionProxy {
    type Protocol = ConnectionMarker;

    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 ConnectionProxy {
    /// Create a new Proxy for fuchsia.bluetooth.le/Connection.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ConnectionMarker 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) -> ConnectionEventStream {
        ConnectionEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Retrieve the range of controller delay for the codec specified with the provided stream
    /// attributes.
    ///
    /// On success, returns the minimum and maximum allowed delay.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if reading the delay is not supported.
    /// Returns ZX_ERR_INTERNAL for all other failures.
    pub fn r#get_codec_local_delay_range(
        &self,
        mut payload: &CodecDelayGetCodecLocalDelayRangeRequest,
    ) -> fidl::client::QueryResponseFut<
        CodecDelayGetCodecLocalDelayRangeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ConnectionProxyInterface::r#get_codec_local_delay_range(self, payload)
    }

    /// The following epitaphs may be sent by the server on error:
    /// + `ZX_ERR_ALREADY_BOUND`: A Client server has already been bound in this Connection
    ///                           protocol. The existing Client should be used.
    pub fn r#request_gatt_client(
        &self,
        mut client: fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt2::ClientMarker>,
    ) -> Result<(), fidl::Error> {
        ConnectionProxyInterface::r#request_gatt_client(self, client)
    }

    /// Accept a future CIS request from the peer with the specified CIG/CIS values. All
    /// CIS requests that have not explicitly been allowed will be rejected.
    ///
    /// The provided IsochronousStream will be used for future notification of established
    /// connections.
    ///
    /// The host may wait for multiple incoming connections simultaneously, although each
    /// must have a combination of CIG/CIS values that is unique to this connection.
    ///
    /// If we are not operating in the peripheral role in this connection, connection_stream
    /// will be closed with a ZX_ERR_NOT_SUPPORTED epitaph.
    ///
    /// If we are already waiting for another connection with the same combination of CIG/CIS
    /// values, connection_stream will be closed with a ZX_ERR_INVALID_ARGS epitaph.
    pub fn r#accept_cis(&self, mut payload: ConnectionAcceptCisRequest) -> Result<(), fidl::Error> {
        ConnectionProxyInterface::r#accept_cis(self, payload)
    }

    /// Connect to an L2CAP LE connection-oriented channel.
    pub fn r#connect_l2cap(
        &self,
        mut payload: ConnectionConnectL2capRequest,
    ) -> Result<(), fidl::Error> {
        ConnectionProxyInterface::r#connect_l2cap(self, payload)
    }
}

impl ConnectionProxyInterface for ConnectionProxy {
    type GetCodecLocalDelayRangeResponseFut = fidl::client::QueryResponseFut<
        CodecDelayGetCodecLocalDelayRangeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_codec_local_delay_range(
        &self,
        mut payload: &CodecDelayGetCodecLocalDelayRangeRequest,
    ) -> Self::GetCodecLocalDelayRangeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<CodecDelayGetCodecLocalDelayRangeResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<CodecDelayGetCodecLocalDelayRangeResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1cf34fdeed80b4d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            CodecDelayGetCodecLocalDelayRangeRequest,
            CodecDelayGetCodecLocalDelayRangeResult,
        >(
            payload,
            0x1cf34fdeed80b4d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#request_gatt_client(
        &self,
        mut client: fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt2::ClientMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ConnectionRequestGattClientRequest>(
            (client,),
            0x2a670e0fec6ccc6b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#accept_cis(&self, mut payload: ConnectionAcceptCisRequest) -> Result<(), fidl::Error> {
        self.client.send::<ConnectionAcceptCisRequest>(
            &mut payload,
            0x7e6338c237088144,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#connect_l2cap(
        &self,
        mut payload: ConnectionConnectL2capRequest,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ConnectionConnectL2capRequest>(
            &mut payload,
            0x12351316feaebce9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ConnectionRequestStream {
    type Protocol = ConnectionMarker;
    type ControlHandle = ConnectionControlHandle;

    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 {
        ConnectionControlHandle { 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 ConnectionRequestStream {
    type Item = Result<ConnectionRequest, 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 ConnectionRequestStream 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 {
                    0x1cf34fdeed80b4d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            CodecDelayGetCodecLocalDelayRangeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CodecDelayGetCodecLocalDelayRangeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ConnectionControlHandle { inner: this.inner.clone() };
                        Ok(ConnectionRequest::GetCodecLocalDelayRange {
                            payload: req,
                            responder: ConnectionGetCodecLocalDelayRangeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2a670e0fec6ccc6b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ConnectionRequestGattClientRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ConnectionRequestGattClientRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ConnectionControlHandle { inner: this.inner.clone() };
                        Ok(ConnectionRequest::RequestGattClient {
                            client: req.client,

                            control_handle,
                        })
                    }
                    0x7e6338c237088144 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ConnectionAcceptCisRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ConnectionAcceptCisRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ConnectionControlHandle { inner: this.inner.clone() };
                        Ok(ConnectionRequest::AcceptCis { payload: req, control_handle })
                    }
                    0x12351316feaebce9 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ConnectionConnectL2capRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ConnectionConnectL2capRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ConnectionControlHandle { inner: this.inner.clone() };
                        Ok(ConnectionRequest::ConnectL2cap { payload: req, control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ConnectionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol that represents the connection to a peer. This can be used to interact with GATT
/// services and establish L2CAP channels.
///
/// This lifetime of this capability is tied to that of the LE connection it represents. Closing the
/// channel results in a disconnection if no other clients hold a Connection to the same peer.
#[derive(Debug)]
pub enum ConnectionRequest {
    /// Retrieve the range of controller delay for the codec specified with the provided stream
    /// attributes.
    ///
    /// On success, returns the minimum and maximum allowed delay.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if reading the delay is not supported.
    /// Returns ZX_ERR_INTERNAL for all other failures.
    GetCodecLocalDelayRange {
        payload: CodecDelayGetCodecLocalDelayRangeRequest,
        responder: ConnectionGetCodecLocalDelayRangeResponder,
    },
    /// The following epitaphs may be sent by the server on error:
    /// + `ZX_ERR_ALREADY_BOUND`: A Client server has already been bound in this Connection
    ///                           protocol. The existing Client should be used.
    RequestGattClient {
        client: fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt2::ClientMarker>,
        control_handle: ConnectionControlHandle,
    },
    /// Accept a future CIS request from the peer with the specified CIG/CIS values. All
    /// CIS requests that have not explicitly been allowed will be rejected.
    ///
    /// The provided IsochronousStream will be used for future notification of established
    /// connections.
    ///
    /// The host may wait for multiple incoming connections simultaneously, although each
    /// must have a combination of CIG/CIS values that is unique to this connection.
    ///
    /// If we are not operating in the peripheral role in this connection, connection_stream
    /// will be closed with a ZX_ERR_NOT_SUPPORTED epitaph.
    ///
    /// If we are already waiting for another connection with the same combination of CIG/CIS
    /// values, connection_stream will be closed with a ZX_ERR_INVALID_ARGS epitaph.
    AcceptCis { payload: ConnectionAcceptCisRequest, control_handle: ConnectionControlHandle },
    /// Connect to an L2CAP LE connection-oriented channel.
    ConnectL2cap { payload: ConnectionConnectL2capRequest, control_handle: ConnectionControlHandle },
}

impl ConnectionRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_codec_local_delay_range(
        self,
    ) -> Option<(
        CodecDelayGetCodecLocalDelayRangeRequest,
        ConnectionGetCodecLocalDelayRangeResponder,
    )> {
        if let ConnectionRequest::GetCodecLocalDelayRange { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_request_gatt_client(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt2::ClientMarker>,
        ConnectionControlHandle,
    )> {
        if let ConnectionRequest::RequestGattClient { client, control_handle } = self {
            Some((client, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_accept_cis(self) -> Option<(ConnectionAcceptCisRequest, ConnectionControlHandle)> {
        if let ConnectionRequest::AcceptCis { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_l2cap(
        self,
    ) -> Option<(ConnectionConnectL2capRequest, ConnectionControlHandle)> {
        if let ConnectionRequest::ConnectL2cap { 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 {
            ConnectionRequest::GetCodecLocalDelayRange { .. } => "get_codec_local_delay_range",
            ConnectionRequest::RequestGattClient { .. } => "request_gatt_client",
            ConnectionRequest::AcceptCis { .. } => "accept_cis",
            ConnectionRequest::ConnectL2cap { .. } => "connect_l2cap",
        }
    }
}

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for IsochronousStreamMarker {
    type Proxy = IsochronousStreamProxy;
    type RequestStream = IsochronousStreamRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = IsochronousStreamSynchronousProxy;

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

pub trait IsochronousStreamProxyInterface: Send + Sync {
    type SetupDataPathResponseFut: std::future::Future<Output = Result<IsochronousStreamSetupDataPathResult, fidl::Error>>
        + Send;
    fn r#setup_data_path(
        &self,
        payload: &IsochronousStreamSetupDataPathRequest,
    ) -> Self::SetupDataPathResponseFut;
    type ReadResponseFut: std::future::Future<Output = Result<IsochronousStreamReadResponse, fidl::Error>>
        + Send;
    fn r#read(&self) -> Self::ReadResponseFut;
    type WriteResponseFut: std::future::Future<Output = Result<IsochronousStreamWriteResult, fidl::Error>>
        + Send;
    fn r#write(&self, payload: &IsochronousStreamWriteRequest) -> Self::WriteResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct IsochronousStreamSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for IsochronousStreamSynchronousProxy {
    type Proxy = IsochronousStreamProxy;
    type Protocol = IsochronousStreamMarker;

    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 IsochronousStreamSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <IsochronousStreamMarker 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<IsochronousStreamEvent, fidl::Error> {
        IsochronousStreamEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Create an isochronous data path with the specified parameters. Only in-band (HCI) ISO
    /// transport is currently supported.
    ///
    /// Returns ZX_ERR_ALREADY_EXISTS if a ISO stream has already been created for this
    /// direction.
    ///
    /// Returns ZX_ERR_BAD_STATE if issued on a peripheral before a CIS request has been
    /// accepted.
    ///
    /// Returns ZX_ERR_INVALID_ARGS if the codec arguments are invalid or outside of the
    /// controller's supported range.
    pub fn r#setup_data_path(
        &self,
        mut payload: &IsochronousStreamSetupDataPathRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<IsochronousStreamSetupDataPathResult, fidl::Error> {
        let _response = self.client.send_query::<
            IsochronousStreamSetupDataPathRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            payload,
            0x7ec1e2b9cc6d2fbe,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<IsochronousStreamMarker>("setup_data_path")?;
        Ok(_response.map(|x| x))
    }

    /// Receive data from an output (controller => host) ISO stream that has been established and
    /// set up. Designed to be used with a hanging get pattern.
    ///
    /// Can be invoked before the ISO data stream has been established and set up, but will not
    /// return until after it has been set up and data has been received.
    pub fn r#read(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<IsochronousStreamReadResponse, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<IsochronousStreamReadResponse>,
        >(
            (),
            0x6d7d8b4950ed3a32,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<IsochronousStreamMarker>("read")?;
        Ok(_response)
    }

    /// Send data to an established ISO stream (host => controller).
    ///
    /// Returns ZX_ERR_INTERNAL for any errors encountered.
    pub fn r#write(
        &self,
        mut payload: &IsochronousStreamWriteRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<IsochronousStreamWriteResult, fidl::Error> {
        let _response = self.client.send_query::<
            IsochronousStreamWriteRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            payload,
            0x5282e90b667d0d43,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<IsochronousStreamMarker>("write")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for IsochronousStreamProxy {
    type Protocol = IsochronousStreamMarker;

    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 IsochronousStreamProxy {
    /// Create a new Proxy for fuchsia.bluetooth.le/IsochronousStream.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <IsochronousStreamMarker 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) -> IsochronousStreamEventStream {
        IsochronousStreamEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Create an isochronous data path with the specified parameters. Only in-band (HCI) ISO
    /// transport is currently supported.
    ///
    /// Returns ZX_ERR_ALREADY_EXISTS if a ISO stream has already been created for this
    /// direction.
    ///
    /// Returns ZX_ERR_BAD_STATE if issued on a peripheral before a CIS request has been
    /// accepted.
    ///
    /// Returns ZX_ERR_INVALID_ARGS if the codec arguments are invalid or outside of the
    /// controller's supported range.
    pub fn r#setup_data_path(
        &self,
        mut payload: &IsochronousStreamSetupDataPathRequest,
    ) -> fidl::client::QueryResponseFut<
        IsochronousStreamSetupDataPathResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        IsochronousStreamProxyInterface::r#setup_data_path(self, payload)
    }

    /// Receive data from an output (controller => host) ISO stream that has been established and
    /// set up. Designed to be used with a hanging get pattern.
    ///
    /// Can be invoked before the ISO data stream has been established and set up, but will not
    /// return until after it has been set up and data has been received.
    pub fn r#read(
        &self,
    ) -> fidl::client::QueryResponseFut<
        IsochronousStreamReadResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        IsochronousStreamProxyInterface::r#read(self)
    }

    /// Send data to an established ISO stream (host => controller).
    ///
    /// Returns ZX_ERR_INTERNAL for any errors encountered.
    pub fn r#write(
        &self,
        mut payload: &IsochronousStreamWriteRequest,
    ) -> fidl::client::QueryResponseFut<
        IsochronousStreamWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        IsochronousStreamProxyInterface::r#write(self, payload)
    }
}

impl IsochronousStreamProxyInterface for IsochronousStreamProxy {
    type SetupDataPathResponseFut = fidl::client::QueryResponseFut<
        IsochronousStreamSetupDataPathResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#setup_data_path(
        &self,
        mut payload: &IsochronousStreamSetupDataPathRequest,
    ) -> Self::SetupDataPathResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<IsochronousStreamSetupDataPathResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7ec1e2b9cc6d2fbe,
            >(_buf?)?
            .into_result::<IsochronousStreamMarker>("setup_data_path")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            IsochronousStreamSetupDataPathRequest,
            IsochronousStreamSetupDataPathResult,
        >(
            payload,
            0x7ec1e2b9cc6d2fbe,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

    type WriteResponseFut = fidl::client::QueryResponseFut<
        IsochronousStreamWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write(&self, mut payload: &IsochronousStreamWriteRequest) -> Self::WriteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<IsochronousStreamWriteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5282e90b667d0d43,
            >(_buf?)?
            .into_result::<IsochronousStreamMarker>("write")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<IsochronousStreamWriteRequest, IsochronousStreamWriteResult>(
                payload,
                0x5282e90b667d0d43,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }
}

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

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

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

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

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

impl IsochronousStreamEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_established(self) -> Option<IsochronousStreamOnEstablishedRequest> {
        if let IsochronousStreamEvent::OnEstablished { payload } = self {
            Some((payload))
        } else {
            None
        }
    }

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

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

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

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

impl fidl::endpoints::RequestStream for IsochronousStreamRequestStream {
    type Protocol = IsochronousStreamMarker;
    type ControlHandle = IsochronousStreamControlHandle;

    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 {
        IsochronousStreamControlHandle { 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 IsochronousStreamRequestStream {
    type Item = Result<IsochronousStreamRequest, 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 IsochronousStreamRequestStream 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 {
                    0x7ec1e2b9cc6d2fbe => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            IsochronousStreamSetupDataPathRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<IsochronousStreamSetupDataPathRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            IsochronousStreamControlHandle { inner: this.inner.clone() };
                        Ok(IsochronousStreamRequest::SetupDataPath {
                            payload: req,
                            responder: IsochronousStreamSetupDataPathResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6d7d8b4950ed3a32 => {
                        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 =
                            IsochronousStreamControlHandle { inner: this.inner.clone() };
                        Ok(IsochronousStreamRequest::Read {
                            responder: IsochronousStreamReadResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5282e90b667d0d43 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            IsochronousStreamWriteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<IsochronousStreamWriteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            IsochronousStreamControlHandle { inner: this.inner.clone() };
                        Ok(IsochronousStreamRequest::Write {
                            payload: req,
                            responder: IsochronousStreamWriteResponder {
                                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(IsochronousStreamRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: IsochronousStreamControlHandle {
                                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(IsochronousStreamRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: IsochronousStreamControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <IsochronousStreamMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum IsochronousStreamRequest {
    /// Create an isochronous data path with the specified parameters. Only in-band (HCI) ISO
    /// transport is currently supported.
    ///
    /// Returns ZX_ERR_ALREADY_EXISTS if a ISO stream has already been created for this
    /// direction.
    ///
    /// Returns ZX_ERR_BAD_STATE if issued on a peripheral before a CIS request has been
    /// accepted.
    ///
    /// Returns ZX_ERR_INVALID_ARGS if the codec arguments are invalid or outside of the
    /// controller's supported range.
    SetupDataPath {
        payload: IsochronousStreamSetupDataPathRequest,
        responder: IsochronousStreamSetupDataPathResponder,
    },
    /// Receive data from an output (controller => host) ISO stream that has been established and
    /// set up. Designed to be used with a hanging get pattern.
    ///
    /// Can be invoked before the ISO data stream has been established and set up, but will not
    /// return until after it has been set up and data has been received.
    Read { responder: IsochronousStreamReadResponder },
    /// Send data to an established ISO stream (host => controller).
    ///
    /// Returns ZX_ERR_INTERNAL for any errors encountered.
    Write { payload: IsochronousStreamWriteRequest, responder: IsochronousStreamWriteResponder },
    /// 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: IsochronousStreamControlHandle,
        method_type: fidl::MethodType,
    },
}

impl IsochronousStreamRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_setup_data_path(
        self,
    ) -> Option<(IsochronousStreamSetupDataPathRequest, IsochronousStreamSetupDataPathResponder)>
    {
        if let IsochronousStreamRequest::SetupDataPath { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read(self) -> Option<(IsochronousStreamReadResponder)> {
        if let IsochronousStreamRequest::Read { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write(
        self,
    ) -> Option<(IsochronousStreamWriteRequest, IsochronousStreamWriteResponder)> {
        if let IsochronousStreamRequest::Write { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for IsochronousStreamControlHandle {
    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 IsochronousStreamControlHandle {
    pub fn send_on_established(
        &self,
        mut payload: &IsochronousStreamOnEstablishedRequest,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<IsochronousStreamOnEstablishedRequest>(
            payload,
            0,
            0x341c50e9d10f3421,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &IsochronousStreamControlHandle {
        &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 IsochronousStreamSetupDataPathResponder {
    /// 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,
            0x7ec1e2b9cc6d2fbe,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

    fn control_handle(&self) -> &IsochronousStreamControlHandle {
        &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 IsochronousStreamWriteResponder {
    /// 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,
            0x5282e90b667d0d43,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for PeripheralMarker {
    type Proxy = PeripheralProxy;
    type RequestStream = PeripheralRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PeripheralSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.le.Peripheral";
}
impl fidl::endpoints::DiscoverableProtocolMarker for PeripheralMarker {}
pub type PeripheralAdvertiseResult = Result<(), PeripheralError>;
pub type PeripheralStartAdvertisingResult = Result<(), PeripheralError>;

pub trait PeripheralProxyInterface: Send + Sync {
    type ListenL2capResponseFut: std::future::Future<Output = Result<ChannelListenerRegistryListenL2capResult, fidl::Error>>
        + Send;
    fn r#listen_l2cap(
        &self,
        payload: ChannelListenerRegistryListenL2capRequest,
    ) -> Self::ListenL2capResponseFut;
    type AdvertiseResponseFut: std::future::Future<Output = Result<PeripheralAdvertiseResult, fidl::Error>>
        + Send;
    fn r#advertise(
        &self,
        parameters: &AdvertisingParameters,
        advertised_peripheral: fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>,
    ) -> Self::AdvertiseResponseFut;
    type StartAdvertisingResponseFut: std::future::Future<Output = Result<PeripheralStartAdvertisingResult, fidl::Error>>
        + Send;
    fn r#start_advertising(
        &self,
        parameters: &AdvertisingParameters,
        handle: fidl::endpoints::ServerEnd<AdvertisingHandleMarker>,
    ) -> Self::StartAdvertisingResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PeripheralSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PeripheralSynchronousProxy {
    type Proxy = PeripheralProxy;
    type Protocol = PeripheralMarker;

    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 PeripheralSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <PeripheralMarker 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<PeripheralEvent, fidl::Error> {
        PeripheralEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Register a listener for incoming channels. The registry will assign a
    /// PSM value that is unique for the local device, as well as open a
    /// [`ChannelListener`] for accepting incoming channels. In the unlikely
    /// event that all PSMs have been assigned, this call will fail with
    /// `ZX_ERR_NO_RESOURCES`.
    ///
    /// Note that the method of service discovery or advertising is defined by
    /// the service or protocol, so it is the responsibility of the caller to
    /// communicate the assigned PSM to any clients.
    pub fn r#listen_l2cap(
        &self,
        mut payload: ChannelListenerRegistryListenL2capRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ChannelListenerRegistryListenL2capResult, fidl::Error> {
        let _response = self.client.send_query::<
            ChannelListenerRegistryListenL2capRequest,
            fidl::encoding::ResultType<ChannelListenerRegistryListenL2capResponse, i32>,
        >(
            &mut payload,
            0x39c6e9001d102338,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Start advertising continuously as a LE peripheral. If advertising cannot
    /// be initiated then `advertised_peripheral` will be closed and an error
    /// will be returned.
    ///
    /// This method may be called any number of times. To reconfigure an
    /// advertisement, first close the original advertisement and then initiate
    /// a new advertisement after an empty response is returned.
    ///
    /// If the client closes its end of the
    /// [`fuchsia.bluetooth.le/AdvertisedPeripheral`] channel,
    /// advertising will be stopped. If the handle is closed before the request
    /// is fulfilled, advertising may be briefly enabled before it is
    /// terminated. AdvertisedPeripheral lifetime is bounded by the lifetime of
    /// the Peripheral protocol, but this may be changed in the future
    /// (https://fxbug.dev/42157682).
    ///
    /// + request `parameters` Parameters used while configuring the advertising
    ///   instance.
    /// + request `advertised_peripheral` Protocol that remains valid for the
    ///   duration of this advertising session.
    /// - response An empty response will be sent when the advertisement is
    ///   successfully stopped (due to release of the `advertised_peripheral`
    ///   protocol). To prevent overlapping similar advertisements and transient
    ///   errors with limited advertising resources, waiting for a response is
    ///   recommended before calling `Advertise` again.
    /// * error If an error occurs, `advertised_peripheral` will be closed and a
    ///   `PeripheralError` will be returned.
    pub fn r#advertise(
        &self,
        mut parameters: &AdvertisingParameters,
        mut advertised_peripheral: fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PeripheralAdvertiseResult, fidl::Error> {
        let _response = self.client.send_query::<
            PeripheralAdvertiseRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, PeripheralError>,
        >(
            (parameters, advertised_peripheral,),
            0x2d9ec9260c32c17f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Start advertising as a LE peripheral. An empty response is sent to indicate when advertising
    /// has successfully initiated. If advertising cannot be initiated, then the response will
    /// contain a [`fuchsia.bluetooth.le/PeripheralError`].
    ///
    /// This method can get called any number of times and successive calls can be made to
    /// reconfigure the advertising parameters. However only the most recent
    /// [`fuchsia.bluetooth.le/AdvertisingHandle`] will remain valid.
    ///
    /// An instance of [`fuchsia.bluetooth.le/Peripheral`] can only have one active advertisement at
    /// a time. Clients must obtain multiple Peripheral instances for multiple simultaneous
    /// advertisements.
    ///
    /// If the client closes its end of the [`fuchsia.bluetooth.le/AdvertisingHandle`] channel,
    /// advertising will be stopped. If the handle is closed before the request is fulfilled,
    /// advertising will be briefly enabled before it is terminated.
    ///
    /// + request `parameters` Parameters used while configuring the advertising instance.
    /// + request `handle` Handle that remains valid for the duration of this advertising session.
    /// * error Returns a [`fuchsia.bluetooth.le/PeripheralError`] if advertising cannot be
    ///         initiated. In this case the `handle` will be closed.
    pub fn r#start_advertising(
        &self,
        mut parameters: &AdvertisingParameters,
        mut handle: fidl::endpoints::ServerEnd<AdvertisingHandleMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PeripheralStartAdvertisingResult, fidl::Error> {
        let _response = self.client.send_query::<
            PeripheralStartAdvertisingRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, PeripheralError>,
        >(
            (parameters, handle,),
            0x5875c1c575f00f7d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PeripheralProxy {
    type Protocol = PeripheralMarker;

    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 PeripheralProxy {
    /// Create a new Proxy for fuchsia.bluetooth.le/Peripheral.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PeripheralMarker 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) -> PeripheralEventStream {
        PeripheralEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Register a listener for incoming channels. The registry will assign a
    /// PSM value that is unique for the local device, as well as open a
    /// [`ChannelListener`] for accepting incoming channels. In the unlikely
    /// event that all PSMs have been assigned, this call will fail with
    /// `ZX_ERR_NO_RESOURCES`.
    ///
    /// Note that the method of service discovery or advertising is defined by
    /// the service or protocol, so it is the responsibility of the caller to
    /// communicate the assigned PSM to any clients.
    pub fn r#listen_l2cap(
        &self,
        mut payload: ChannelListenerRegistryListenL2capRequest,
    ) -> fidl::client::QueryResponseFut<
        ChannelListenerRegistryListenL2capResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PeripheralProxyInterface::r#listen_l2cap(self, payload)
    }

    /// Start advertising continuously as a LE peripheral. If advertising cannot
    /// be initiated then `advertised_peripheral` will be closed and an error
    /// will be returned.
    ///
    /// This method may be called any number of times. To reconfigure an
    /// advertisement, first close the original advertisement and then initiate
    /// a new advertisement after an empty response is returned.
    ///
    /// If the client closes its end of the
    /// [`fuchsia.bluetooth.le/AdvertisedPeripheral`] channel,
    /// advertising will be stopped. If the handle is closed before the request
    /// is fulfilled, advertising may be briefly enabled before it is
    /// terminated. AdvertisedPeripheral lifetime is bounded by the lifetime of
    /// the Peripheral protocol, but this may be changed in the future
    /// (https://fxbug.dev/42157682).
    ///
    /// + request `parameters` Parameters used while configuring the advertising
    ///   instance.
    /// + request `advertised_peripheral` Protocol that remains valid for the
    ///   duration of this advertising session.
    /// - response An empty response will be sent when the advertisement is
    ///   successfully stopped (due to release of the `advertised_peripheral`
    ///   protocol). To prevent overlapping similar advertisements and transient
    ///   errors with limited advertising resources, waiting for a response is
    ///   recommended before calling `Advertise` again.
    /// * error If an error occurs, `advertised_peripheral` will be closed and a
    ///   `PeripheralError` will be returned.
    pub fn r#advertise(
        &self,
        mut parameters: &AdvertisingParameters,
        mut advertised_peripheral: fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>,
    ) -> fidl::client::QueryResponseFut<
        PeripheralAdvertiseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PeripheralProxyInterface::r#advertise(self, parameters, advertised_peripheral)
    }

    /// Start advertising as a LE peripheral. An empty response is sent to indicate when advertising
    /// has successfully initiated. If advertising cannot be initiated, then the response will
    /// contain a [`fuchsia.bluetooth.le/PeripheralError`].
    ///
    /// This method can get called any number of times and successive calls can be made to
    /// reconfigure the advertising parameters. However only the most recent
    /// [`fuchsia.bluetooth.le/AdvertisingHandle`] will remain valid.
    ///
    /// An instance of [`fuchsia.bluetooth.le/Peripheral`] can only have one active advertisement at
    /// a time. Clients must obtain multiple Peripheral instances for multiple simultaneous
    /// advertisements.
    ///
    /// If the client closes its end of the [`fuchsia.bluetooth.le/AdvertisingHandle`] channel,
    /// advertising will be stopped. If the handle is closed before the request is fulfilled,
    /// advertising will be briefly enabled before it is terminated.
    ///
    /// + request `parameters` Parameters used while configuring the advertising instance.
    /// + request `handle` Handle that remains valid for the duration of this advertising session.
    /// * error Returns a [`fuchsia.bluetooth.le/PeripheralError`] if advertising cannot be
    ///         initiated. In this case the `handle` will be closed.
    pub fn r#start_advertising(
        &self,
        mut parameters: &AdvertisingParameters,
        mut handle: fidl::endpoints::ServerEnd<AdvertisingHandleMarker>,
    ) -> fidl::client::QueryResponseFut<
        PeripheralStartAdvertisingResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PeripheralProxyInterface::r#start_advertising(self, parameters, handle)
    }
}

impl PeripheralProxyInterface for PeripheralProxy {
    type ListenL2capResponseFut = fidl::client::QueryResponseFut<
        ChannelListenerRegistryListenL2capResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#listen_l2cap(
        &self,
        mut payload: ChannelListenerRegistryListenL2capRequest,
    ) -> Self::ListenL2capResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ChannelListenerRegistryListenL2capResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ChannelListenerRegistryListenL2capResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x39c6e9001d102338,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ChannelListenerRegistryListenL2capRequest,
            ChannelListenerRegistryListenL2capResult,
        >(
            &mut payload,
            0x39c6e9001d102338,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AdvertiseResponseFut = fidl::client::QueryResponseFut<
        PeripheralAdvertiseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#advertise(
        &self,
        mut parameters: &AdvertisingParameters,
        mut advertised_peripheral: fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>,
    ) -> Self::AdvertiseResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PeripheralAdvertiseResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, PeripheralError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2d9ec9260c32c17f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<PeripheralAdvertiseRequest, PeripheralAdvertiseResult>(
            (parameters, advertised_peripheral),
            0x2d9ec9260c32c17f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartAdvertisingResponseFut = fidl::client::QueryResponseFut<
        PeripheralStartAdvertisingResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start_advertising(
        &self,
        mut parameters: &AdvertisingParameters,
        mut handle: fidl::endpoints::ServerEnd<AdvertisingHandleMarker>,
    ) -> Self::StartAdvertisingResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PeripheralStartAdvertisingResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, PeripheralError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5875c1c575f00f7d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            PeripheralStartAdvertisingRequest,
            PeripheralStartAdvertisingResult,
        >(
            (parameters, handle,),
            0x5875c1c575f00f7d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum PeripheralEvent {
    OnPeerConnected { peer: Peer, connection: fidl::endpoints::ClientEnd<ConnectionMarker> },
}

impl PeripheralEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_peer_connected(
        self,
    ) -> Option<(Peer, fidl::endpoints::ClientEnd<ConnectionMarker>)> {
        if let PeripheralEvent::OnPeerConnected { peer, connection } = self {
            Some((peer, connection))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`PeripheralEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<PeripheralEvent, 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 {
            0x16135d464299e356 => {
                let mut out = fidl::new_empty!(
                    PeripheralOnPeerConnectedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeripheralOnPeerConnectedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((PeripheralEvent::OnPeerConnected {
                    peer: out.peer,
                    connection: out.connection,
                }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <PeripheralMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for PeripheralRequestStream {
    type Protocol = PeripheralMarker;
    type ControlHandle = PeripheralControlHandle;

    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 {
        PeripheralControlHandle { 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 PeripheralRequestStream {
    type Item = Result<PeripheralRequest, 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 PeripheralRequestStream 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 {
                    0x39c6e9001d102338 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ChannelListenerRegistryListenL2capRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelListenerRegistryListenL2capRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeripheralControlHandle { inner: this.inner.clone() };
                        Ok(PeripheralRequest::ListenL2cap {
                            payload: req,
                            responder: PeripheralListenL2capResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2d9ec9260c32c17f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PeripheralAdvertiseRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeripheralAdvertiseRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeripheralControlHandle { inner: this.inner.clone() };
                        Ok(PeripheralRequest::Advertise {
                            parameters: req.parameters,
                            advertised_peripheral: req.advertised_peripheral,

                            responder: PeripheralAdvertiseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5875c1c575f00f7d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PeripheralStartAdvertisingRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeripheralStartAdvertisingRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PeripheralControlHandle { inner: this.inner.clone() };
                        Ok(PeripheralRequest::StartAdvertising {
                            parameters: req.parameters,
                            handle: req.handle,

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

#[derive(Debug)]
pub enum PeripheralRequest {
    /// Register a listener for incoming channels. The registry will assign a
    /// PSM value that is unique for the local device, as well as open a
    /// [`ChannelListener`] for accepting incoming channels. In the unlikely
    /// event that all PSMs have been assigned, this call will fail with
    /// `ZX_ERR_NO_RESOURCES`.
    ///
    /// Note that the method of service discovery or advertising is defined by
    /// the service or protocol, so it is the responsibility of the caller to
    /// communicate the assigned PSM to any clients.
    ListenL2cap {
        payload: ChannelListenerRegistryListenL2capRequest,
        responder: PeripheralListenL2capResponder,
    },
    /// Start advertising continuously as a LE peripheral. If advertising cannot
    /// be initiated then `advertised_peripheral` will be closed and an error
    /// will be returned.
    ///
    /// This method may be called any number of times. To reconfigure an
    /// advertisement, first close the original advertisement and then initiate
    /// a new advertisement after an empty response is returned.
    ///
    /// If the client closes its end of the
    /// [`fuchsia.bluetooth.le/AdvertisedPeripheral`] channel,
    /// advertising will be stopped. If the handle is closed before the request
    /// is fulfilled, advertising may be briefly enabled before it is
    /// terminated. AdvertisedPeripheral lifetime is bounded by the lifetime of
    /// the Peripheral protocol, but this may be changed in the future
    /// (https://fxbug.dev/42157682).
    ///
    /// + request `parameters` Parameters used while configuring the advertising
    ///   instance.
    /// + request `advertised_peripheral` Protocol that remains valid for the
    ///   duration of this advertising session.
    /// - response An empty response will be sent when the advertisement is
    ///   successfully stopped (due to release of the `advertised_peripheral`
    ///   protocol). To prevent overlapping similar advertisements and transient
    ///   errors with limited advertising resources, waiting for a response is
    ///   recommended before calling `Advertise` again.
    /// * error If an error occurs, `advertised_peripheral` will be closed and a
    ///   `PeripheralError` will be returned.
    Advertise {
        parameters: AdvertisingParameters,
        advertised_peripheral: fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>,
        responder: PeripheralAdvertiseResponder,
    },
    /// Start advertising as a LE peripheral. An empty response is sent to indicate when advertising
    /// has successfully initiated. If advertising cannot be initiated, then the response will
    /// contain a [`fuchsia.bluetooth.le/PeripheralError`].
    ///
    /// This method can get called any number of times and successive calls can be made to
    /// reconfigure the advertising parameters. However only the most recent
    /// [`fuchsia.bluetooth.le/AdvertisingHandle`] will remain valid.
    ///
    /// An instance of [`fuchsia.bluetooth.le/Peripheral`] can only have one active advertisement at
    /// a time. Clients must obtain multiple Peripheral instances for multiple simultaneous
    /// advertisements.
    ///
    /// If the client closes its end of the [`fuchsia.bluetooth.le/AdvertisingHandle`] channel,
    /// advertising will be stopped. If the handle is closed before the request is fulfilled,
    /// advertising will be briefly enabled before it is terminated.
    ///
    /// + request `parameters` Parameters used while configuring the advertising instance.
    /// + request `handle` Handle that remains valid for the duration of this advertising session.
    /// * error Returns a [`fuchsia.bluetooth.le/PeripheralError`] if advertising cannot be
    ///         initiated. In this case the `handle` will be closed.
    StartAdvertising {
        parameters: AdvertisingParameters,
        handle: fidl::endpoints::ServerEnd<AdvertisingHandleMarker>,
        responder: PeripheralStartAdvertisingResponder,
    },
}

impl PeripheralRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_listen_l2cap(
        self,
    ) -> Option<(ChannelListenerRegistryListenL2capRequest, PeripheralListenL2capResponder)> {
        if let PeripheralRequest::ListenL2cap { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_advertise(
        self,
    ) -> Option<(
        AdvertisingParameters,
        fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>,
        PeripheralAdvertiseResponder,
    )> {
        if let PeripheralRequest::Advertise { parameters, advertised_peripheral, responder } = self
        {
            Some((parameters, advertised_peripheral, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start_advertising(
        self,
    ) -> Option<(
        AdvertisingParameters,
        fidl::endpoints::ServerEnd<AdvertisingHandleMarker>,
        PeripheralStartAdvertisingResponder,
    )> {
        if let PeripheralRequest::StartAdvertising { parameters, handle, responder } = self {
            Some((parameters, handle, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PeripheralRequest::ListenL2cap { .. } => "listen_l2cap",
            PeripheralRequest::Advertise { .. } => "advertise",
            PeripheralRequest::StartAdvertising { .. } => "start_advertising",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for PeripheralControlHandle {
    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 PeripheralControlHandle {
    pub fn send_on_peer_connected(
        &self,
        mut peer: &Peer,
        mut connection: fidl::endpoints::ClientEnd<ConnectionMarker>,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<PeripheralOnPeerConnectedRequest>(
            (peer, connection),
            0,
            0x16135d464299e356,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for PrivilegedPeripheralMarker {
    type Proxy = PrivilegedPeripheralProxy;
    type RequestStream = PrivilegedPeripheralRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PrivilegedPeripheralSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.bluetooth.le.PrivilegedPeripheral";
}
impl fidl::endpoints::DiscoverableProtocolMarker for PrivilegedPeripheralMarker {}

pub trait PrivilegedPeripheralProxyInterface: Send + Sync {
    type ListenL2capResponseFut: std::future::Future<Output = Result<ChannelListenerRegistryListenL2capResult, fidl::Error>>
        + Send;
    fn r#listen_l2cap(
        &self,
        payload: ChannelListenerRegistryListenL2capRequest,
    ) -> Self::ListenL2capResponseFut;
    type AdvertiseResponseFut: std::future::Future<Output = Result<PeripheralAdvertiseResult, fidl::Error>>
        + Send;
    fn r#advertise(
        &self,
        parameters: &AdvertisingParameters,
        advertised_peripheral: fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>,
    ) -> Self::AdvertiseResponseFut;
    type StartAdvertisingResponseFut: std::future::Future<Output = Result<PeripheralStartAdvertisingResult, fidl::Error>>
        + Send;
    fn r#start_advertising(
        &self,
        parameters: &AdvertisingParameters,
        handle: fidl::endpoints::ServerEnd<AdvertisingHandleMarker>,
    ) -> Self::StartAdvertisingResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PrivilegedPeripheralSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PrivilegedPeripheralSynchronousProxy {
    type Proxy = PrivilegedPeripheralProxy;
    type Protocol = PrivilegedPeripheralMarker;

    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 PrivilegedPeripheralSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <PrivilegedPeripheralMarker 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<PrivilegedPeripheralEvent, fidl::Error> {
        PrivilegedPeripheralEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Register a listener for incoming channels. The registry will assign a
    /// PSM value that is unique for the local device, as well as open a
    /// [`ChannelListener`] for accepting incoming channels. In the unlikely
    /// event that all PSMs have been assigned, this call will fail with
    /// `ZX_ERR_NO_RESOURCES`.
    ///
    /// Note that the method of service discovery or advertising is defined by
    /// the service or protocol, so it is the responsibility of the caller to
    /// communicate the assigned PSM to any clients.
    pub fn r#listen_l2cap(
        &self,
        mut payload: ChannelListenerRegistryListenL2capRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ChannelListenerRegistryListenL2capResult, fidl::Error> {
        let _response = self.client.send_query::<
            ChannelListenerRegistryListenL2capRequest,
            fidl::encoding::ResultType<ChannelListenerRegistryListenL2capResponse, i32>,
        >(
            &mut payload,
            0x39c6e9001d102338,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Start advertising continuously as a LE peripheral. If advertising cannot
    /// be initiated then `advertised_peripheral` will be closed and an error
    /// will be returned.
    ///
    /// This method may be called any number of times. To reconfigure an
    /// advertisement, first close the original advertisement and then initiate
    /// a new advertisement after an empty response is returned.
    ///
    /// If the client closes its end of the
    /// [`fuchsia.bluetooth.le/AdvertisedPeripheral`] channel,
    /// advertising will be stopped. If the handle is closed before the request
    /// is fulfilled, advertising may be briefly enabled before it is
    /// terminated. AdvertisedPeripheral lifetime is bounded by the lifetime of
    /// the Peripheral protocol, but this may be changed in the future
    /// (https://fxbug.dev/42157682).
    ///
    /// + request `parameters` Parameters used while configuring the advertising
    ///   instance.
    /// + request `advertised_peripheral` Protocol that remains valid for the
    ///   duration of this advertising session.
    /// - response An empty response will be sent when the advertisement is
    ///   successfully stopped (due to release of the `advertised_peripheral`
    ///   protocol). To prevent overlapping similar advertisements and transient
    ///   errors with limited advertising resources, waiting for a response is
    ///   recommended before calling `Advertise` again.
    /// * error If an error occurs, `advertised_peripheral` will be closed and a
    ///   `PeripheralError` will be returned.
    pub fn r#advertise(
        &self,
        mut parameters: &AdvertisingParameters,
        mut advertised_peripheral: fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PeripheralAdvertiseResult, fidl::Error> {
        let _response = self.client.send_query::<
            PeripheralAdvertiseRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, PeripheralError>,
        >(
            (parameters, advertised_peripheral,),
            0x2d9ec9260c32c17f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Start advertising as a LE peripheral. An empty response is sent to indicate when advertising
    /// has successfully initiated. If advertising cannot be initiated, then the response will
    /// contain a [`fuchsia.bluetooth.le/PeripheralError`].
    ///
    /// This method can get called any number of times and successive calls can be made to
    /// reconfigure the advertising parameters. However only the most recent
    /// [`fuchsia.bluetooth.le/AdvertisingHandle`] will remain valid.
    ///
    /// An instance of [`fuchsia.bluetooth.le/Peripheral`] can only have one active advertisement at
    /// a time. Clients must obtain multiple Peripheral instances for multiple simultaneous
    /// advertisements.
    ///
    /// If the client closes its end of the [`fuchsia.bluetooth.le/AdvertisingHandle`] channel,
    /// advertising will be stopped. If the handle is closed before the request is fulfilled,
    /// advertising will be briefly enabled before it is terminated.
    ///
    /// + request `parameters` Parameters used while configuring the advertising instance.
    /// + request `handle` Handle that remains valid for the duration of this advertising session.
    /// * error Returns a [`fuchsia.bluetooth.le/PeripheralError`] if advertising cannot be
    ///         initiated. In this case the `handle` will be closed.
    pub fn r#start_advertising(
        &self,
        mut parameters: &AdvertisingParameters,
        mut handle: fidl::endpoints::ServerEnd<AdvertisingHandleMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PeripheralStartAdvertisingResult, fidl::Error> {
        let _response = self.client.send_query::<
            PeripheralStartAdvertisingRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, PeripheralError>,
        >(
            (parameters, handle,),
            0x5875c1c575f00f7d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for PrivilegedPeripheralProxy {
    type Protocol = PrivilegedPeripheralMarker;

    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 PrivilegedPeripheralProxy {
    /// Create a new Proxy for fuchsia.bluetooth.le/PrivilegedPeripheral.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <PrivilegedPeripheralMarker 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) -> PrivilegedPeripheralEventStream {
        PrivilegedPeripheralEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Register a listener for incoming channels. The registry will assign a
    /// PSM value that is unique for the local device, as well as open a
    /// [`ChannelListener`] for accepting incoming channels. In the unlikely
    /// event that all PSMs have been assigned, this call will fail with
    /// `ZX_ERR_NO_RESOURCES`.
    ///
    /// Note that the method of service discovery or advertising is defined by
    /// the service or protocol, so it is the responsibility of the caller to
    /// communicate the assigned PSM to any clients.
    pub fn r#listen_l2cap(
        &self,
        mut payload: ChannelListenerRegistryListenL2capRequest,
    ) -> fidl::client::QueryResponseFut<
        ChannelListenerRegistryListenL2capResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PrivilegedPeripheralProxyInterface::r#listen_l2cap(self, payload)
    }

    /// Start advertising continuously as a LE peripheral. If advertising cannot
    /// be initiated then `advertised_peripheral` will be closed and an error
    /// will be returned.
    ///
    /// This method may be called any number of times. To reconfigure an
    /// advertisement, first close the original advertisement and then initiate
    /// a new advertisement after an empty response is returned.
    ///
    /// If the client closes its end of the
    /// [`fuchsia.bluetooth.le/AdvertisedPeripheral`] channel,
    /// advertising will be stopped. If the handle is closed before the request
    /// is fulfilled, advertising may be briefly enabled before it is
    /// terminated. AdvertisedPeripheral lifetime is bounded by the lifetime of
    /// the Peripheral protocol, but this may be changed in the future
    /// (https://fxbug.dev/42157682).
    ///
    /// + request `parameters` Parameters used while configuring the advertising
    ///   instance.
    /// + request `advertised_peripheral` Protocol that remains valid for the
    ///   duration of this advertising session.
    /// - response An empty response will be sent when the advertisement is
    ///   successfully stopped (due to release of the `advertised_peripheral`
    ///   protocol). To prevent overlapping similar advertisements and transient
    ///   errors with limited advertising resources, waiting for a response is
    ///   recommended before calling `Advertise` again.
    /// * error If an error occurs, `advertised_peripheral` will be closed and a
    ///   `PeripheralError` will be returned.
    pub fn r#advertise(
        &self,
        mut parameters: &AdvertisingParameters,
        mut advertised_peripheral: fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>,
    ) -> fidl::client::QueryResponseFut<
        PeripheralAdvertiseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PrivilegedPeripheralProxyInterface::r#advertise(self, parameters, advertised_peripheral)
    }

    /// Start advertising as a LE peripheral. An empty response is sent to indicate when advertising
    /// has successfully initiated. If advertising cannot be initiated, then the response will
    /// contain a [`fuchsia.bluetooth.le/PeripheralError`].
    ///
    /// This method can get called any number of times and successive calls can be made to
    /// reconfigure the advertising parameters. However only the most recent
    /// [`fuchsia.bluetooth.le/AdvertisingHandle`] will remain valid.
    ///
    /// An instance of [`fuchsia.bluetooth.le/Peripheral`] can only have one active advertisement at
    /// a time. Clients must obtain multiple Peripheral instances for multiple simultaneous
    /// advertisements.
    ///
    /// If the client closes its end of the [`fuchsia.bluetooth.le/AdvertisingHandle`] channel,
    /// advertising will be stopped. If the handle is closed before the request is fulfilled,
    /// advertising will be briefly enabled before it is terminated.
    ///
    /// + request `parameters` Parameters used while configuring the advertising instance.
    /// + request `handle` Handle that remains valid for the duration of this advertising session.
    /// * error Returns a [`fuchsia.bluetooth.le/PeripheralError`] if advertising cannot be
    ///         initiated. In this case the `handle` will be closed.
    pub fn r#start_advertising(
        &self,
        mut parameters: &AdvertisingParameters,
        mut handle: fidl::endpoints::ServerEnd<AdvertisingHandleMarker>,
    ) -> fidl::client::QueryResponseFut<
        PeripheralStartAdvertisingResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PrivilegedPeripheralProxyInterface::r#start_advertising(self, parameters, handle)
    }
}

impl PrivilegedPeripheralProxyInterface for PrivilegedPeripheralProxy {
    type ListenL2capResponseFut = fidl::client::QueryResponseFut<
        ChannelListenerRegistryListenL2capResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#listen_l2cap(
        &self,
        mut payload: ChannelListenerRegistryListenL2capRequest,
    ) -> Self::ListenL2capResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ChannelListenerRegistryListenL2capResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ChannelListenerRegistryListenL2capResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x39c6e9001d102338,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ChannelListenerRegistryListenL2capRequest,
            ChannelListenerRegistryListenL2capResult,
        >(
            &mut payload,
            0x39c6e9001d102338,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AdvertiseResponseFut = fidl::client::QueryResponseFut<
        PeripheralAdvertiseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#advertise(
        &self,
        mut parameters: &AdvertisingParameters,
        mut advertised_peripheral: fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>,
    ) -> Self::AdvertiseResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PeripheralAdvertiseResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, PeripheralError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2d9ec9260c32c17f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<PeripheralAdvertiseRequest, PeripheralAdvertiseResult>(
            (parameters, advertised_peripheral),
            0x2d9ec9260c32c17f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StartAdvertisingResponseFut = fidl::client::QueryResponseFut<
        PeripheralStartAdvertisingResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start_advertising(
        &self,
        mut parameters: &AdvertisingParameters,
        mut handle: fidl::endpoints::ServerEnd<AdvertisingHandleMarker>,
    ) -> Self::StartAdvertisingResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PeripheralStartAdvertisingResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, PeripheralError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5875c1c575f00f7d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            PeripheralStartAdvertisingRequest,
            PeripheralStartAdvertisingResult,
        >(
            (parameters, handle,),
            0x5875c1c575f00f7d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum PrivilegedPeripheralEvent {
    OnPeerConnected { peer: Peer, connection: fidl::endpoints::ClientEnd<ConnectionMarker> },
}

impl PrivilegedPeripheralEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_peer_connected(
        self,
    ) -> Option<(Peer, fidl::endpoints::ClientEnd<ConnectionMarker>)> {
        if let PrivilegedPeripheralEvent::OnPeerConnected { peer, connection } = self {
            Some((peer, connection))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`PrivilegedPeripheralEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<PrivilegedPeripheralEvent, 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 {
            0x16135d464299e356 => {
                let mut out = fidl::new_empty!(
                    PeripheralOnPeerConnectedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeripheralOnPeerConnectedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((PrivilegedPeripheralEvent::OnPeerConnected {
                    peer: out.peer,
                    connection: out.connection,
                }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <PrivilegedPeripheralMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for PrivilegedPeripheralRequestStream {
    type Protocol = PrivilegedPeripheralMarker;
    type ControlHandle = PrivilegedPeripheralControlHandle;

    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 {
        PrivilegedPeripheralControlHandle { 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 PrivilegedPeripheralRequestStream {
    type Item = Result<PrivilegedPeripheralRequest, 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 PrivilegedPeripheralRequestStream 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 {
                0x39c6e9001d102338 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(ChannelListenerRegistryListenL2capRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelListenerRegistryListenL2capRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = PrivilegedPeripheralControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PrivilegedPeripheralRequest::ListenL2cap {payload: req,
                        responder: PrivilegedPeripheralListenL2capResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2d9ec9260c32c17f => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(PeripheralAdvertiseRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeripheralAdvertiseRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = PrivilegedPeripheralControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PrivilegedPeripheralRequest::Advertise {parameters: req.parameters,
advertised_peripheral: req.advertised_peripheral,

                        responder: PrivilegedPeripheralAdvertiseResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x5875c1c575f00f7d => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(PeripheralStartAdvertisingRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PeripheralStartAdvertisingRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = PrivilegedPeripheralControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PrivilegedPeripheralRequest::StartAdvertising {parameters: req.parameters,
handle: req.handle,

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

/// Privileged version of the Peripheral protocol.
/// This protocol should only be routed to trusted and system components. Using this protocol will
/// enable the client to break normal privacy restrictions which could leak information about the
/// location or owner of the device.
///
/// Use cases which reveal information are noted in documentation and marked as only available
/// through PrivilegedPeripheral, and are an error if used through Peripheral.
#[derive(Debug)]
pub enum PrivilegedPeripheralRequest {
    /// Register a listener for incoming channels. The registry will assign a
    /// PSM value that is unique for the local device, as well as open a
    /// [`ChannelListener`] for accepting incoming channels. In the unlikely
    /// event that all PSMs have been assigned, this call will fail with
    /// `ZX_ERR_NO_RESOURCES`.
    ///
    /// Note that the method of service discovery or advertising is defined by
    /// the service or protocol, so it is the responsibility of the caller to
    /// communicate the assigned PSM to any clients.
    ListenL2cap {
        payload: ChannelListenerRegistryListenL2capRequest,
        responder: PrivilegedPeripheralListenL2capResponder,
    },
    /// Start advertising continuously as a LE peripheral. If advertising cannot
    /// be initiated then `advertised_peripheral` will be closed and an error
    /// will be returned.
    ///
    /// This method may be called any number of times. To reconfigure an
    /// advertisement, first close the original advertisement and then initiate
    /// a new advertisement after an empty response is returned.
    ///
    /// If the client closes its end of the
    /// [`fuchsia.bluetooth.le/AdvertisedPeripheral`] channel,
    /// advertising will be stopped. If the handle is closed before the request
    /// is fulfilled, advertising may be briefly enabled before it is
    /// terminated. AdvertisedPeripheral lifetime is bounded by the lifetime of
    /// the Peripheral protocol, but this may be changed in the future
    /// (https://fxbug.dev/42157682).
    ///
    /// + request `parameters` Parameters used while configuring the advertising
    ///   instance.
    /// + request `advertised_peripheral` Protocol that remains valid for the
    ///   duration of this advertising session.
    /// - response An empty response will be sent when the advertisement is
    ///   successfully stopped (due to release of the `advertised_peripheral`
    ///   protocol). To prevent overlapping similar advertisements and transient
    ///   errors with limited advertising resources, waiting for a response is
    ///   recommended before calling `Advertise` again.
    /// * error If an error occurs, `advertised_peripheral` will be closed and a
    ///   `PeripheralError` will be returned.
    Advertise {
        parameters: AdvertisingParameters,
        advertised_peripheral: fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>,
        responder: PrivilegedPeripheralAdvertiseResponder,
    },
    /// Start advertising as a LE peripheral. An empty response is sent to indicate when advertising
    /// has successfully initiated. If advertising cannot be initiated, then the response will
    /// contain a [`fuchsia.bluetooth.le/PeripheralError`].
    ///
    /// This method can get called any number of times and successive calls can be made to
    /// reconfigure the advertising parameters. However only the most recent
    /// [`fuchsia.bluetooth.le/AdvertisingHandle`] will remain valid.
    ///
    /// An instance of [`fuchsia.bluetooth.le/Peripheral`] can only have one active advertisement at
    /// a time. Clients must obtain multiple Peripheral instances for multiple simultaneous
    /// advertisements.
    ///
    /// If the client closes its end of the [`fuchsia.bluetooth.le/AdvertisingHandle`] channel,
    /// advertising will be stopped. If the handle is closed before the request is fulfilled,
    /// advertising will be briefly enabled before it is terminated.
    ///
    /// + request `parameters` Parameters used while configuring the advertising instance.
    /// + request `handle` Handle that remains valid for the duration of this advertising session.
    /// * error Returns a [`fuchsia.bluetooth.le/PeripheralError`] if advertising cannot be
    ///         initiated. In this case the `handle` will be closed.
    StartAdvertising {
        parameters: AdvertisingParameters,
        handle: fidl::endpoints::ServerEnd<AdvertisingHandleMarker>,
        responder: PrivilegedPeripheralStartAdvertisingResponder,
    },
}

impl PrivilegedPeripheralRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_listen_l2cap(
        self,
    ) -> Option<(ChannelListenerRegistryListenL2capRequest, PrivilegedPeripheralListenL2capResponder)>
    {
        if let PrivilegedPeripheralRequest::ListenL2cap { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_advertise(
        self,
    ) -> Option<(
        AdvertisingParameters,
        fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>,
        PrivilegedPeripheralAdvertiseResponder,
    )> {
        if let PrivilegedPeripheralRequest::Advertise {
            parameters,
            advertised_peripheral,
            responder,
        } = self
        {
            Some((parameters, advertised_peripheral, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start_advertising(
        self,
    ) -> Option<(
        AdvertisingParameters,
        fidl::endpoints::ServerEnd<AdvertisingHandleMarker>,
        PrivilegedPeripheralStartAdvertisingResponder,
    )> {
        if let PrivilegedPeripheralRequest::StartAdvertising { parameters, handle, responder } =
            self
        {
            Some((parameters, handle, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PrivilegedPeripheralRequest::ListenL2cap { .. } => "listen_l2cap",
            PrivilegedPeripheralRequest::Advertise { .. } => "advertise",
            PrivilegedPeripheralRequest::StartAdvertising { .. } => "start_advertising",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for PrivilegedPeripheralControlHandle {
    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 PrivilegedPeripheralControlHandle {
    pub fn send_on_peer_connected(
        &self,
        mut peer: &Peer,
        mut connection: fidl::endpoints::ClientEnd<ConnectionMarker>,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<PeripheralOnPeerConnectedRequest>(
            (peer, connection),
            0,
            0x16135d464299e356,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ScanResultWatcherMarker {
    type Proxy = ScanResultWatcherProxy;
    type RequestStream = ScanResultWatcherRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ScanResultWatcherSynchronousProxy;

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

pub trait ScanResultWatcherProxyInterface: Send + Sync {
    type WatchResponseFut: std::future::Future<Output = Result<Vec<Peer>, fidl::Error>> + Send;
    fn r#watch(&self) -> Self::WatchResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ScanResultWatcherSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ScanResultWatcherSynchronousProxy {
    type Proxy = ScanResultWatcherProxy;
    type Protocol = ScanResultWatcherMarker;

    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 ScanResultWatcherSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <ScanResultWatcherMarker 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<ScanResultWatcherEvent, fidl::Error> {
        ScanResultWatcherEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Returns a list of all LE peers that satisfy the filters indicated in
    /// `ScanOptions`. The first response(s) will return matching discovered
    /// peers immediately. Subsequent calls receive a response only when peers
    /// have been scanned or updated since the last call. If a second call to
    /// `Watch` is erronously sent while one call is already pending, the scan
    /// will be canceled and the protocol will be closed.
    ///
    /// - response `updated` Peers that were added or updated since the last
    ///   call to Watch().
    pub fn r#watch(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<Peer>, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, ScanResultWatcherWatchResponse>(
                (),
                0x713a122e949f301a,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.updated)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ScanResultWatcherProxy {
    type Protocol = ScanResultWatcherMarker;

    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 ScanResultWatcherProxy {
    /// Create a new Proxy for fuchsia.bluetooth.le/ScanResultWatcher.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <ScanResultWatcherMarker 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) -> ScanResultWatcherEventStream {
        ScanResultWatcherEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns a list of all LE peers that satisfy the filters indicated in
    /// `ScanOptions`. The first response(s) will return matching discovered
    /// peers immediately. Subsequent calls receive a response only when peers
    /// have been scanned or updated since the last call. If a second call to
    /// `Watch` is erronously sent while one call is already pending, the scan
    /// will be canceled and the protocol will be closed.
    ///
    /// - response `updated` Peers that were added or updated since the last
    ///   call to Watch().
    pub fn r#watch(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<Peer>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        ScanResultWatcherProxyInterface::r#watch(self)
    }
}

impl ScanResultWatcherProxyInterface for ScanResultWatcherProxy {
    type WatchResponseFut =
        fidl::client::QueryResponseFut<Vec<Peer>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#watch(&self) -> Self::WatchResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<Peer>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ScanResultWatcherWatchResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x713a122e949f301a,
            >(_buf?)?;
            Ok(_response.updated)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<Peer>>(
            (),
            0x713a122e949f301a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ScanResultWatcherRequestStream {
    type Protocol = ScanResultWatcherMarker;
    type ControlHandle = ScanResultWatcherControlHandle;

    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 {
        ScanResultWatcherControlHandle { 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 ScanResultWatcherRequestStream {
    type Item = Result<ScanResultWatcherRequest, 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 ScanResultWatcherRequestStream 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 {
                    0x713a122e949f301a => {
                        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 =
                            ScanResultWatcherControlHandle { inner: this.inner.clone() };
                        Ok(ScanResultWatcherRequest::Watch {
                            responder: ScanResultWatcherWatchResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ScanResultWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Represents an active scan procedure. This protocol remains valid for the
/// duration of a scan and can be used to obtain scan results. The client can
/// close the protocol to stop scanning. If a scan is stopped by the system, the
/// protocol will be closed with the epitaph `CANCELED` to communicate this to
/// the client.
#[derive(Debug)]
pub enum ScanResultWatcherRequest {
    /// Returns a list of all LE peers that satisfy the filters indicated in
    /// `ScanOptions`. The first response(s) will return matching discovered
    /// peers immediately. Subsequent calls receive a response only when peers
    /// have been scanned or updated since the last call. If a second call to
    /// `Watch` is erronously sent while one call is already pending, the scan
    /// will be canceled and the protocol will be closed.
    ///
    /// - response `updated` Peers that were added or updated since the last
    ///   call to Watch().
    Watch { responder: ScanResultWatcherWatchResponder },
}

impl ScanResultWatcherRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch(self) -> Option<(ScanResultWatcherWatchResponder)> {
        if let ScanResultWatcherRequest::Watch { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

    fn send_raw(&self, mut updated: &[Peer]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ScanResultWatcherWatchResponse>(
            (updated,),
            self.tx_id,
            0x713a122e949f301a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            AdvertisedPeripheralOnConnectedRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut AdvertisedPeripheralOnConnectedRequest
    {
        #[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::<AdvertisedPeripheralOnConnectedRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AdvertisedPeripheralOnConnectedRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <Peer as fidl::encoding::ValueTypeMarker>::borrow(&self.peer),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ConnectionMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.connection),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<Peer, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ConnectionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            AdvertisedPeripheralOnConnectedRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AdvertisedPeripheralOnConnectedRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for AdvertisedPeripheralOnConnectedRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer: fidl::new_empty!(Peer, fidl::encoding::DefaultFuchsiaResourceDialect),
                connection: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ConnectionMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                Peer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.peer,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ConnectionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.connection,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            CentralConnectPeripheralRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut CentralConnectPeripheralRequest
    {
        #[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::<CentralConnectPeripheralRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                CentralConnectPeripheralRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.identifier,
                    ),
                    <ConnectionOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt::ClientMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.gatt_client
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<16>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                ConnectionOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt::ClientMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            CentralConnectPeripheralRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CentralConnectPeripheralRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CentralConnectPeripheralRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                identifier: fidl::new_empty!(
                    fidl::encoding::BoundedString<16>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                options: fidl::new_empty!(
                    ConnectionOptions,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                gatt_client: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt::ClientMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<16>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.identifier,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                ConnectionOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.options,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth_gatt::ClientMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.gatt_client,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<CentralConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut CentralConnectRequest
    {
        #[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::<CentralConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CentralConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_bluetooth::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
                    <ConnectionOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ConnectionMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl_fuchsia_bluetooth::PeerId,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                ConnectionOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ConnectionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<CentralConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CentralConnectRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CentralConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(
                    fidl_fuchsia_bluetooth::PeerId,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                options: fidl::new_empty!(
                    ConnectionOptions,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                handle: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ConnectionMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl_fuchsia_bluetooth::PeerId,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                ConnectionOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.options,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ConnectionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handle,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<CentralScanRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut CentralScanRequest
    {
        #[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::<CentralScanRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CentralScanRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <ScanOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ScanResultWatcherMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.result_watcher),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<ScanOptions, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ScanResultWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<CentralScanRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CentralScanRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CentralScanRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                options: fidl::new_empty!(
                    ScanOptions,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                result_watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ScanResultWatcherMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                ScanOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.options,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ScanResultWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.result_watcher,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            PeripheralAdvertiseRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PeripheralAdvertiseRequest
    {
        #[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::<PeripheralAdvertiseRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                PeripheralAdvertiseRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <AdvertisingParameters as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.parameters,
                    ),
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.advertised_peripheral,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                AdvertisingParameters,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            PeripheralAdvertiseRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PeripheralAdvertiseRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PeripheralAdvertiseRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                parameters: fidl::new_empty!(
                    AdvertisingParameters,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                advertised_peripheral: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                AdvertisingParameters,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.parameters,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<AdvertisedPeripheralMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.advertised_peripheral,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            PeripheralOnPeerConnectedRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PeripheralOnPeerConnectedRequest
    {
        #[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::<PeripheralOnPeerConnectedRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PeripheralOnPeerConnectedRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <Peer as fidl::encoding::ValueTypeMarker>::borrow(&self.peer),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ConnectionMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.connection),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<Peer, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ConnectionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            PeripheralOnPeerConnectedRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PeripheralOnPeerConnectedRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PeripheralOnPeerConnectedRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                peer: fidl::new_empty!(Peer, fidl::encoding::DefaultFuchsiaResourceDialect),
                connection: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ConnectionMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                Peer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.peer,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ConnectionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.connection,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            PeripheralStartAdvertisingRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PeripheralStartAdvertisingRequest
    {
        #[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::<PeripheralStartAdvertisingRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PeripheralStartAdvertisingRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <AdvertisingParameters as fidl::encoding::ValueTypeMarker>::borrow(&self.parameters),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AdvertisingHandleMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                AdvertisingParameters,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AdvertisingHandleMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            PeripheralStartAdvertisingRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PeripheralStartAdvertisingRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PeripheralStartAdvertisingRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                parameters: fidl::new_empty!(
                    AdvertisingParameters,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                handle: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AdvertisingHandleMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                AdvertisingParameters,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.parameters,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AdvertisingHandleMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handle,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl CentralCreateConnectedIsochronousGroupRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.cig {
                return 3;
            }
            if let Some(_) = self.cis_requested_parameters {
                return 2;
            }
            if let Some(_) = self.cig_parameters {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for CentralCreateConnectedIsochronousGroupRequest {
        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 CentralCreateConnectedIsochronousGroupRequest {
        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<
            CentralCreateConnectedIsochronousGroupRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut CentralCreateConnectedIsochronousGroupRequest
    {
        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::<CentralCreateConnectedIsochronousGroupRequest>(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::<
                CigParameters,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.cig_parameters
                    .as_ref()
                    .map(<CigParameters 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::<fidl::encoding::Vector<CisRequestedParameters, 31>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.cis_requested_parameters.as_mut().map(<fidl::encoding::Vector<CisRequestedParameters, 31> as fidl::encoding::ResourceTypeMarker>::take_or_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<ConnectedIsochronousGroupMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.cig.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<ConnectedIsochronousGroupMarker>,
                    > 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 CentralCreateConnectedIsochronousGroupRequest
    {
        #[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 =
                    <CigParameters 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.cig_parameters.get_or_insert_with(|| {
                    fidl::new_empty!(CigParameters, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    CigParameters,
                    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 = <fidl::encoding::Vector<CisRequestedParameters, 31> 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.cis_requested_parameters.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<CisRequestedParameters, 31>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::Vector<CisRequestedParameters, 31>, 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<ConnectedIsochronousGroupMarker>,
                > 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.cig.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ServerEnd<ConnectedIsochronousGroupMarker>,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<ConnectedIsochronousGroupMarker>,
                    >,
                    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 ChannelListenerRegistryListenL2capRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.listener {
                return 2;
            }
            if let Some(_) = self.parameters {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ChannelListenerRegistryListenL2capRequest {
        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 ChannelListenerRegistryListenL2capRequest {
        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<
            ChannelListenerRegistryListenL2capRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ChannelListenerRegistryListenL2capRequest
    {
        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::<ChannelListenerRegistryListenL2capRequest>(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::<
                AcceptedChannelParameters,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.parameters
                    .as_ref()
                    .map(<AcceptedChannelParameters 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::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ChannelListenerMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.listener.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ChannelListenerMarker>> 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 ChannelListenerRegistryListenL2capRequest
    {
        #[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 =
                    <AcceptedChannelParameters 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.parameters.get_or_insert_with(|| {
                    fidl::new_empty!(
                        AcceptedChannelParameters,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    AcceptedChannelParameters,
                    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 = <fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<ChannelListenerMarker>,
                > 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.listener.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ChannelListenerMarker>>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ChannelListenerMarker>>,
                    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 CisRequestedParameters {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.max_sdu_size_incoming {
                return 4;
            }
            if let Some(_) = self.max_sdu_size_outgoing {
                return 3;
            }
            if let Some(_) = self.connection_stream {
                return 2;
            }
            if let Some(_) = self.cis_id {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for CisRequestedParameters {
        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 CisRequestedParameters {
        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<
            CisRequestedParameters,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut CisRequestedParameters
    {
        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::<CisRequestedParameters>(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::<
                u8,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.cis_id.as_ref().map(<u8 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::<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<IsochronousStreamMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.connection_stream.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<IsochronousStreamMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_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::<
                u16,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.max_sdu_size_outgoing
                    .as_ref()
                    .map(<u16 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::<
                u16,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.max_sdu_size_incoming
                    .as_ref()
                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CisRequestedParameters
    {
        #[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 =
                    <u8 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.cis_id.get_or_insert_with(|| {
                    fidl::new_empty!(u8, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u8,
                    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 = <fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<IsochronousStreamMarker>,
                > 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_stream.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ServerEnd<IsochronousStreamMarker>,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<IsochronousStreamMarker>>,
                    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 =
                    <u16 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.max_sdu_size_outgoing.get_or_insert_with(|| {
                    fidl::new_empty!(u16, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u16,
                    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 =
                    <u16 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.max_sdu_size_incoming.get_or_insert_with(|| {
                    fidl::new_empty!(u16, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u16,
                    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 ConnectionAcceptCisRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.connection_stream {
                return 3;
            }
            if let Some(_) = self.cis_id {
                return 2;
            }
            if let Some(_) = self.cig_id {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ConnectionAcceptCisRequest {
        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 ConnectionAcceptCisRequest {
        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<
            ConnectionAcceptCisRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ConnectionAcceptCisRequest
    {
        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::<ConnectionAcceptCisRequest>(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::<
                u8,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.cig_id.as_ref().map(<u8 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::<
                u8,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.cis_id.as_ref().map(<u8 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<IsochronousStreamMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.connection_stream.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<IsochronousStreamMarker>> 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 ConnectionAcceptCisRequest
    {
        #[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 =
                    <u8 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.cig_id.get_or_insert_with(|| {
                    fidl::new_empty!(u8, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u8,
                    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 =
                    <u8 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.cis_id.get_or_insert_with(|| {
                    fidl::new_empty!(u8, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u8,
                    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<IsochronousStreamMarker>,
                > 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_stream.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ServerEnd<IsochronousStreamMarker>,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<IsochronousStreamMarker>>,
                    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 ConnectionConnectL2capRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.psm {
                return 3;
            }
            if let Some(_) = self.channel {
                return 2;
            }
            if let Some(_) = self.parameters {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ConnectionConnectL2capRequest {
        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 ConnectionConnectL2capRequest {
        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<
            ConnectionConnectL2capRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ConnectionConnectL2capRequest
    {
        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::<ConnectionConnectL2capRequest>(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::ChannelParameters, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.parameters.as_ref().map(<fidl_fuchsia_bluetooth::ChannelParameters 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::<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth::ChannelMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.channel.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth::ChannelMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_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::<
                u16,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.psm.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ConnectionConnectL2capRequest
    {
        #[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::ChannelParameters 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.parameters.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl_fuchsia_bluetooth::ChannelParameters,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_bluetooth::ChannelParameters,
                    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 = <fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth::ChannelMarker>,
                > 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<fidl_fuchsia_bluetooth::ChannelMarker>,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_bluetooth::ChannelMarker>,
                    >,
                    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 =
                    <u16 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.psm.get_or_insert_with(|| {
                    fidl::new_empty!(u16, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u16,
                    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(())
        }
    }
}