fidl_fuchsia_hardware_qualcomm_router/

fidl_fuchsia_hardware_qualcomm_router.rs

// WARNING: This file is machine generated by fidlgen.

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fidl::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
pub use fidl_fuchsia_hardware_qualcomm_router_common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct QrtrClientConnectionGetSignalsResponse {
    pub signals: fidl::EventPair,
}

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

#[derive(Debug, PartialEq)]
pub struct QrtrConnectorGetConnectionRequest {
    pub options: ConnectionOptions,
    pub proxy: fidl::endpoints::ServerEnd<QrtrClientConnectionMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct QrtrTransportConnectorEstablishConnectionRequest {
    pub options: TransportConnectionOptions,
    pub proxy: fidl::endpoints::ClientEnd<QrtrTransportChannelMarker>,
}

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

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

impl fidl::endpoints::ProtocolMarker for QrtrClientConnectionMarker {
    type Proxy = QrtrClientConnectionProxy;
    type RequestStream = QrtrClientConnectionRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = QrtrClientConnectionSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) QrtrClientConnection";
}
pub type QrtrClientConnectionReadResult = Result<(u32, u32, Vec<u8>), Error>;
pub type QrtrClientConnectionWriteResult = Result<(), Error>;

pub trait QrtrClientConnectionProxyInterface: Send + Sync {
    type ReadResponseFut: std::future::Future<Output = Result<QrtrClientConnectionReadResult, fidl::Error>>
        + Send;
    fn r#read(&self) -> Self::ReadResponseFut;
    type WriteResponseFut: std::future::Future<Output = Result<QrtrClientConnectionWriteResult, fidl::Error>>
        + Send;
    fn r#write(&self, dst_node_id: u32, dst_port: u32, data: &[u8]) -> Self::WriteResponseFut;
    type GetSignalsResponseFut: std::future::Future<Output = Result<fidl::EventPair, fidl::Error>>
        + Send;
    fn r#get_signals(&self) -> Self::GetSignalsResponseFut;
    type GetPortIdResponseFut: std::future::Future<Output = Result<u32, fidl::Error>> + Send;
    fn r#get_port_id(&self) -> Self::GetPortIdResponseFut;
    type GetNodeIdResponseFut: std::future::Future<Output = Result<u32, fidl::Error>> + Send;
    fn r#get_node_id(&self) -> Self::GetNodeIdResponseFut;
    type CloseConnectionResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#close_connection(&self) -> Self::CloseConnectionResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct QrtrClientConnectionSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for QrtrClientConnectionSynchronousProxy {
    type Proxy = QrtrClientConnectionProxy;
    type Protocol = QrtrClientConnectionMarker;

    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 QrtrClientConnectionSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Reads a QRTR frame via the connection.
    ///
    /// Only one read request can be performed at a time.
    /// - `src_node_id`: Source node ID of the QRTR frame.
    /// - `src_port`: Source port of the QRTR frame.
    /// - `data`: QRTR payload.
    /// * Errors:
    ///   - `WOULD_BLOCK`: Cannot read; should wait in non-blocking mode.
    ///   - `ALREADY_PENDING`: More than one read operation is pending in blocking mode.
    ///   - `INTERNAL_ERROR`: Unexpected QRTR error.
    pub fn r#read(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<QrtrClientConnectionReadResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<QrtrClientConnectionReadResponse, Error>,
            QrtrClientConnectionMarker,
        >(
            (),
            0x1647cf125346d619,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<QrtrClientConnectionMarker>("read")?;
        Ok(_response.map(|x| (x.src_node_id, x.src_port, x.data)))
    }

    /// Writes a QRTR frame.
    ///
    /// Only one write request can be performed at a time.
    /// * Errors:
    ///   - `WOULD_BLOCK`: Cannot write; should wait in non-blocking mode.
    ///   - `ALREADY_PENDING`: More than one write operation is pending in blocking mode.
    ///   - `REMOTE_NODE_UNAVAILABLE`: Target node unavailable.
    ///   - `INTERNAL_ERROR`: Unexpected QRTR error.
    pub fn r#write(
        &self,
        mut dst_node_id: u32,
        mut dst_port: u32,
        mut data: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<QrtrClientConnectionWriteResult, fidl::Error> {
        let _response = self.client.send_query::<
            QrtrClientConnectionWriteRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            QrtrClientConnectionMarker,
        >(
            (dst_node_id, dst_port, data,),
            0x777f5423e2e75f51,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<QrtrClientConnectionMarker>("write")?;
        Ok(_response.map(|x| x))
    }

    /// Retrieves the signals eventpair.
    ///
    /// - response `signals` an eventpair that is signalled with
    ///            `SIGNAL_READABLE` and `SIGNAL_WRITABLE` when
    ///            read and write buffers are available, respectively.
    pub fn r#get_signals(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl::EventPair, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<QrtrClientConnectionGetSignalsResponse>,
            QrtrClientConnectionMarker,
        >(
            (),
            0x6a71227b57862ad7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<QrtrClientConnectionMarker>("get_signals")?;
        Ok(_response.signals)
    }

    /// Retrieves the port id.
    pub fn r#get_port_id(&self, ___deadline: zx::MonotonicInstant) -> Result<u32, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<QrtrClientConnectionGetPortIdResponse>,
            QrtrClientConnectionMarker,
        >(
            (),
            0xb66d6d257f16ad2,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<QrtrClientConnectionMarker>("get_port_id")?;
        Ok(_response.port_id)
    }

    /// Retrieves the node id of AP.
    pub fn r#get_node_id(&self, ___deadline: zx::MonotonicInstant) -> Result<u32, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<QrtrClientConnectionGetNodeIdResponse>,
            QrtrClientConnectionMarker,
        >(
            (),
            0x2ddd28cdb89d2c44,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<QrtrClientConnectionMarker>("get_node_id")?;
        Ok(_response.node_id)
    }

    /// Close the connection.
    ///
    /// Server end drops its end of the channel after replying. This can be
    /// used for synchronous resource release.
    pub fn r#close_connection(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
            QrtrClientConnectionMarker,
        >(
            (),
            0x4645ccec1b86380f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<QrtrClientConnectionMarker>("close_connection")?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for QrtrClientConnectionProxy {
    type Protocol = QrtrClientConnectionMarker;

    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 QrtrClientConnectionProxy {
    /// Create a new Proxy for fuchsia.hardware.qualcomm.router/QrtrClientConnection.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <QrtrClientConnectionMarker 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) -> QrtrClientConnectionEventStream {
        QrtrClientConnectionEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Reads a QRTR frame via the connection.
    ///
    /// Only one read request can be performed at a time.
    /// - `src_node_id`: Source node ID of the QRTR frame.
    /// - `src_port`: Source port of the QRTR frame.
    /// - `data`: QRTR payload.
    /// * Errors:
    ///   - `WOULD_BLOCK`: Cannot read; should wait in non-blocking mode.
    ///   - `ALREADY_PENDING`: More than one read operation is pending in blocking mode.
    ///   - `INTERNAL_ERROR`: Unexpected QRTR error.
    pub fn r#read(
        &self,
    ) -> fidl::client::QueryResponseFut<
        QrtrClientConnectionReadResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        QrtrClientConnectionProxyInterface::r#read(self)
    }

    /// Writes a QRTR frame.
    ///
    /// Only one write request can be performed at a time.
    /// * Errors:
    ///   - `WOULD_BLOCK`: Cannot write; should wait in non-blocking mode.
    ///   - `ALREADY_PENDING`: More than one write operation is pending in blocking mode.
    ///   - `REMOTE_NODE_UNAVAILABLE`: Target node unavailable.
    ///   - `INTERNAL_ERROR`: Unexpected QRTR error.
    pub fn r#write(
        &self,
        mut dst_node_id: u32,
        mut dst_port: u32,
        mut data: &[u8],
    ) -> fidl::client::QueryResponseFut<
        QrtrClientConnectionWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        QrtrClientConnectionProxyInterface::r#write(self, dst_node_id, dst_port, data)
    }

    /// Retrieves the signals eventpair.
    ///
    /// - response `signals` an eventpair that is signalled with
    ///            `SIGNAL_READABLE` and `SIGNAL_WRITABLE` when
    ///            read and write buffers are available, respectively.
    pub fn r#get_signals(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fidl::EventPair,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        QrtrClientConnectionProxyInterface::r#get_signals(self)
    }

    /// Retrieves the port id.
    pub fn r#get_port_id(
        &self,
    ) -> fidl::client::QueryResponseFut<u32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        QrtrClientConnectionProxyInterface::r#get_port_id(self)
    }

    /// Retrieves the node id of AP.
    pub fn r#get_node_id(
        &self,
    ) -> fidl::client::QueryResponseFut<u32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        QrtrClientConnectionProxyInterface::r#get_node_id(self)
    }

    /// Close the connection.
    ///
    /// Server end drops its end of the channel after replying. This can be
    /// used for synchronous resource release.
    pub fn r#close_connection(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        QrtrClientConnectionProxyInterface::r#close_connection(self)
    }
}

impl QrtrClientConnectionProxyInterface for QrtrClientConnectionProxy {
    type ReadResponseFut = fidl::client::QueryResponseFut<
        QrtrClientConnectionReadResult,
        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<QrtrClientConnectionReadResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<QrtrClientConnectionReadResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1647cf125346d619,
            >(_buf?)?
            .into_result::<QrtrClientConnectionMarker>("read")?;
            Ok(_response.map(|x| (x.src_node_id, x.src_port, x.data)))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, QrtrClientConnectionReadResult>(
                (),
                0x1647cf125346d619,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type WriteResponseFut = fidl::client::QueryResponseFut<
        QrtrClientConnectionWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write(
        &self,
        mut dst_node_id: u32,
        mut dst_port: u32,
        mut data: &[u8],
    ) -> Self::WriteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<QrtrClientConnectionWriteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x777f5423e2e75f51,
            >(_buf?)?
            .into_result::<QrtrClientConnectionMarker>("write")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            QrtrClientConnectionWriteRequest,
            QrtrClientConnectionWriteResult,
        >(
            (dst_node_id, dst_port, data,),
            0x777f5423e2e75f51,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetSignalsResponseFut = fidl::client::QueryResponseFut<
        fidl::EventPair,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_signals(&self) -> Self::GetSignalsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl::EventPair, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<QrtrClientConnectionGetSignalsResponse>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6a71227b57862ad7,
            >(_buf?)?
            .into_result::<QrtrClientConnectionMarker>("get_signals")?;
            Ok(_response.signals)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, fidl::EventPair>(
            (),
            0x6a71227b57862ad7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetPortIdResponseFut =
        fidl::client::QueryResponseFut<u32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_port_id(&self) -> Self::GetPortIdResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<QrtrClientConnectionGetPortIdResponse>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xb66d6d257f16ad2,
            >(_buf?)?
            .into_result::<QrtrClientConnectionMarker>("get_port_id")?;
            Ok(_response.port_id)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u32>(
            (),
            0xb66d6d257f16ad2,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetNodeIdResponseFut =
        fidl::client::QueryResponseFut<u32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_node_id(&self) -> Self::GetNodeIdResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<QrtrClientConnectionGetNodeIdResponse>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2ddd28cdb89d2c44,
            >(_buf?)?
            .into_result::<QrtrClientConnectionMarker>("get_node_id")?;
            Ok(_response.node_id)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u32>(
            (),
            0x2ddd28cdb89d2c44,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type CloseConnectionResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#close_connection(&self) -> Self::CloseConnectionResponseFut {
        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,
                0x4645ccec1b86380f,
            >(_buf?)?
            .into_result::<QrtrClientConnectionMarker>("close_connection")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x4645ccec1b86380f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for QrtrClientConnectionRequestStream {
    type Protocol = QrtrClientConnectionMarker;
    type ControlHandle = QrtrClientConnectionControlHandle;

    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 {
        QrtrClientConnectionControlHandle { 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 QrtrClientConnectionRequestStream {
    type Item = Result<QrtrClientConnectionRequest, 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 QrtrClientConnectionRequestStream 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 {
                0x1647cf125346d619 => {
                    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 = QrtrClientConnectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(QrtrClientConnectionRequest::Read {
                        responder: QrtrClientConnectionReadResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x777f5423e2e75f51 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(QrtrClientConnectionWriteRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<QrtrClientConnectionWriteRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = QrtrClientConnectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(QrtrClientConnectionRequest::Write {dst_node_id: req.dst_node_id,
dst_port: req.dst_port,
data: req.data,

                        responder: QrtrClientConnectionWriteResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6a71227b57862ad7 => {
                    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 = QrtrClientConnectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(QrtrClientConnectionRequest::GetSignals {
                        responder: QrtrClientConnectionGetSignalsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0xb66d6d257f16ad2 => {
                    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 = QrtrClientConnectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(QrtrClientConnectionRequest::GetPortId {
                        responder: QrtrClientConnectionGetPortIdResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2ddd28cdb89d2c44 => {
                    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 = QrtrClientConnectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(QrtrClientConnectionRequest::GetNodeId {
                        responder: QrtrClientConnectionGetNodeIdResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4645ccec1b86380f => {
                    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 = QrtrClientConnectionControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(QrtrClientConnectionRequest::CloseConnection {
                        responder: QrtrClientConnectionCloseConnectionResponder {
                            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(QrtrClientConnectionRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: QrtrClientConnectionControlHandle { 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(QrtrClientConnectionRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: QrtrClientConnectionControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <QrtrClientConnectionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// The connection used between a QRTR client and the QRTR driver.
#[derive(Debug)]
pub enum QrtrClientConnectionRequest {
    /// Reads a QRTR frame via the connection.
    ///
    /// Only one read request can be performed at a time.
    /// - `src_node_id`: Source node ID of the QRTR frame.
    /// - `src_port`: Source port of the QRTR frame.
    /// - `data`: QRTR payload.
    /// * Errors:
    ///   - `WOULD_BLOCK`: Cannot read; should wait in non-blocking mode.
    ///   - `ALREADY_PENDING`: More than one read operation is pending in blocking mode.
    ///   - `INTERNAL_ERROR`: Unexpected QRTR error.
    Read { responder: QrtrClientConnectionReadResponder },
    /// Writes a QRTR frame.
    ///
    /// Only one write request can be performed at a time.
    /// * Errors:
    ///   - `WOULD_BLOCK`: Cannot write; should wait in non-blocking mode.
    ///   - `ALREADY_PENDING`: More than one write operation is pending in blocking mode.
    ///   - `REMOTE_NODE_UNAVAILABLE`: Target node unavailable.
    ///   - `INTERNAL_ERROR`: Unexpected QRTR error.
    Write {
        dst_node_id: u32,
        dst_port: u32,
        data: Vec<u8>,
        responder: QrtrClientConnectionWriteResponder,
    },
    /// Retrieves the signals eventpair.
    ///
    /// - response `signals` an eventpair that is signalled with
    ///            `SIGNAL_READABLE` and `SIGNAL_WRITABLE` when
    ///            read and write buffers are available, respectively.
    GetSignals { responder: QrtrClientConnectionGetSignalsResponder },
    /// Retrieves the port id.
    GetPortId { responder: QrtrClientConnectionGetPortIdResponder },
    /// Retrieves the node id of AP.
    GetNodeId { responder: QrtrClientConnectionGetNodeIdResponder },
    /// Close the connection.
    ///
    /// Server end drops its end of the channel after replying. This can be
    /// used for synchronous resource release.
    CloseConnection { responder: QrtrClientConnectionCloseConnectionResponder },
    /// 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: QrtrClientConnectionControlHandle,
        method_type: fidl::MethodType,
    },
}

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_write(self) -> Option<(u32, u32, Vec<u8>, QrtrClientConnectionWriteResponder)> {
        if let QrtrClientConnectionRequest::Write { dst_node_id, dst_port, data, responder } = self
        {
            Some((dst_node_id, dst_port, data, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_signals(self) -> Option<(QrtrClientConnectionGetSignalsResponder)> {
        if let QrtrClientConnectionRequest::GetSignals { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_port_id(self) -> Option<(QrtrClientConnectionGetPortIdResponder)> {
        if let QrtrClientConnectionRequest::GetPortId { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_node_id(self) -> Option<(QrtrClientConnectionGetNodeIdResponder)> {
        if let QrtrClientConnectionRequest::GetNodeId { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close_connection(self) -> Option<(QrtrClientConnectionCloseConnectionResponder)> {
        if let QrtrClientConnectionRequest::CloseConnection { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            QrtrClientConnectionRequest::Read { .. } => "read",
            QrtrClientConnectionRequest::Write { .. } => "write",
            QrtrClientConnectionRequest::GetSignals { .. } => "get_signals",
            QrtrClientConnectionRequest::GetPortId { .. } => "get_port_id",
            QrtrClientConnectionRequest::GetNodeId { .. } => "get_node_id",
            QrtrClientConnectionRequest::CloseConnection { .. } => "close_connection",
            QrtrClientConnectionRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay,
                ..
            } => "unknown one-way method",
            QrtrClientConnectionRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay,
                ..
            } => "unknown two-way method",
        }
    }
}

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl QrtrClientConnectionControlHandle {}

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

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

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

    fn send_raw(&self, mut result: Result<(u32, u32, &[u8]), Error>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            QrtrClientConnectionReadResponse,
            Error,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x1647cf125346d619,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for QrtrConnectorMarker {
    type Proxy = QrtrConnectorProxy;
    type RequestStream = QrtrConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = QrtrConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.hardware.qualcomm.router.QrtrConnector";
}
impl fidl::endpoints::DiscoverableProtocolMarker for QrtrConnectorMarker {}
pub type QrtrConnectorGetConnectionResult = Result<(), Error>;

pub trait QrtrConnectorProxyInterface: Send + Sync {
    type GetConnectionResponseFut: std::future::Future<Output = Result<QrtrConnectorGetConnectionResult, fidl::Error>>
        + Send;
    fn r#get_connection(
        &self,
        options: &ConnectionOptions,
        proxy: fidl::endpoints::ServerEnd<QrtrClientConnectionMarker>,
    ) -> Self::GetConnectionResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct QrtrConnectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for QrtrConnectorSynchronousProxy {
    type Proxy = QrtrConnectorProxy;
    type Protocol = QrtrConnectorMarker;

    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 QrtrConnectorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Gets a new connection from QRTR.
    ///
    /// If `port` is specificed in options, creates a connection with target
    /// port. Otherwise, assigns a random port for the connection.
    /// * Errors:
    ///   - `INTERNAL_ERROR`: Unexpected QRTR error.
    ///   - `INVALID_ARGS`: Invalid arguments in `ConnectionOptions`.
    ///   - `NO_RESOURCES`: No non-reserved port available.
    ///   - `ALREADY_BOUND`: Specified port in `ConnectionOptions` is in use.
    pub fn r#get_connection(
        &self,
        mut options: &ConnectionOptions,
        mut proxy: fidl::endpoints::ServerEnd<QrtrClientConnectionMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<QrtrConnectorGetConnectionResult, fidl::Error> {
        let _response = self.client.send_query::<
            QrtrConnectorGetConnectionRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            QrtrConnectorMarker,
        >(
            (options, proxy,),
            0x1df578179c1f2445,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<QrtrConnectorMarker>("get_connection")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for QrtrConnectorProxy {
    type Protocol = QrtrConnectorMarker;

    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 QrtrConnectorProxy {
    /// Create a new Proxy for fuchsia.hardware.qualcomm.router/QrtrConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <QrtrConnectorMarker 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) -> QrtrConnectorEventStream {
        QrtrConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets a new connection from QRTR.
    ///
    /// If `port` is specificed in options, creates a connection with target
    /// port. Otherwise, assigns a random port for the connection.
    /// * Errors:
    ///   - `INTERNAL_ERROR`: Unexpected QRTR error.
    ///   - `INVALID_ARGS`: Invalid arguments in `ConnectionOptions`.
    ///   - `NO_RESOURCES`: No non-reserved port available.
    ///   - `ALREADY_BOUND`: Specified port in `ConnectionOptions` is in use.
    pub fn r#get_connection(
        &self,
        mut options: &ConnectionOptions,
        mut proxy: fidl::endpoints::ServerEnd<QrtrClientConnectionMarker>,
    ) -> fidl::client::QueryResponseFut<
        QrtrConnectorGetConnectionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        QrtrConnectorProxyInterface::r#get_connection(self, options, proxy)
    }
}

impl QrtrConnectorProxyInterface for QrtrConnectorProxy {
    type GetConnectionResponseFut = fidl::client::QueryResponseFut<
        QrtrConnectorGetConnectionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_connection(
        &self,
        mut options: &ConnectionOptions,
        mut proxy: fidl::endpoints::ServerEnd<QrtrClientConnectionMarker>,
    ) -> Self::GetConnectionResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<QrtrConnectorGetConnectionResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1df578179c1f2445,
            >(_buf?)?
            .into_result::<QrtrConnectorMarker>("get_connection")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            QrtrConnectorGetConnectionRequest,
            QrtrConnectorGetConnectionResult,
        >(
            (options, proxy,),
            0x1df578179c1f2445,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for QrtrConnectorRequestStream {
    type Protocol = QrtrConnectorMarker;
    type ControlHandle = QrtrConnectorControlHandle;

    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 {
        QrtrConnectorControlHandle { 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 QrtrConnectorRequestStream {
    type Item = Result<QrtrConnectorRequest, 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 QrtrConnectorRequestStream 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 {
                    0x1df578179c1f2445 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            QrtrConnectorGetConnectionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<QrtrConnectorGetConnectionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            QrtrConnectorControlHandle { inner: this.inner.clone() };
                        Ok(QrtrConnectorRequest::GetConnection {
                            options: req.options,
                            proxy: req.proxy,

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

/// Vends client connections with no access constraints in QRTR.
#[derive(Debug)]
pub enum QrtrConnectorRequest {
    /// Gets a new connection from QRTR.
    ///
    /// If `port` is specificed in options, creates a connection with target
    /// port. Otherwise, assigns a random port for the connection.
    /// * Errors:
    ///   - `INTERNAL_ERROR`: Unexpected QRTR error.
    ///   - `INVALID_ARGS`: Invalid arguments in `ConnectionOptions`.
    ///   - `NO_RESOURCES`: No non-reserved port available.
    ///   - `ALREADY_BOUND`: Specified port in `ConnectionOptions` is in use.
    GetConnection {
        options: ConnectionOptions,
        proxy: fidl::endpoints::ServerEnd<QrtrClientConnectionMarker>,
        responder: QrtrConnectorGetConnectionResponder,
    },
    /// 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: QrtrConnectorControlHandle,
        method_type: fidl::MethodType,
    },
}

impl QrtrConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_connection(
        self,
    ) -> Option<(
        ConnectionOptions,
        fidl::endpoints::ServerEnd<QrtrClientConnectionMarker>,
        QrtrConnectorGetConnectionResponder,
    )> {
        if let QrtrConnectorRequest::GetConnection { options, proxy, responder } = self {
            Some((options, proxy, responder))
        } else {
            None
        }
    }

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

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl QrtrConnectorControlHandle {}

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for QrtrTransportChannelMarker {
    type Proxy = QrtrTransportChannelProxy;
    type RequestStream = QrtrTransportChannelRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = QrtrTransportChannelSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) QrtrTransportChannel";
}
pub type QrtrTransportChannelReadResult = Result<Vec<u8>, Error>;
pub type QrtrTransportChannelWriteResult = Result<(), Error>;

pub trait QrtrTransportChannelProxyInterface: Send + Sync {
    type ReadResponseFut: std::future::Future<Output = Result<QrtrTransportChannelReadResult, fidl::Error>>
        + Send;
    fn r#read(&self) -> Self::ReadResponseFut;
    type WriteResponseFut: std::future::Future<Output = Result<QrtrTransportChannelWriteResult, fidl::Error>>
        + Send;
    fn r#write(&self, data: &[u8]) -> Self::WriteResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct QrtrTransportChannelSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for QrtrTransportChannelSynchronousProxy {
    type Proxy = QrtrTransportChannelProxy;
    type Protocol = QrtrTransportChannelMarker;

    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 QrtrTransportChannelSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Reads a QRTR frame from a transport driver.
    ///
    /// Blocks until an inbound frame is ready to be consumed.
    /// Only one read request can be performed at a time.
    /// - `data`: QRTR frame.
    /// * Errors:
    ///   - `ALREADY_PENDING`: More than one read operation is pending.
    ///   - `INTERNAL_ERROR`: Unexpected QRTR error.
    pub fn r#read(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<QrtrTransportChannelReadResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<QrtrTransportChannelReadResponse, Error>,
            QrtrTransportChannelMarker,
        >(
            (),
            0x1ea3f950c311b3e9,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<QrtrTransportChannelMarker>("read")?;
        Ok(_response.map(|x| x.data))
    }

    /// Writes a QRTR frame to a transport driver.
    ///
    /// Only one write request can be performed at a time.
    /// * Errors:
    ///   - `ALREADY_PENDING`: More than one write operation is pending.
    ///   - `INTERNAL_ERROR`: Unexpected QRTR error.
    pub fn r#write(
        &self,
        mut data: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<QrtrTransportChannelWriteResult, fidl::Error> {
        let _response = self.client.send_query::<
            QrtrTransportChannelWriteRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            QrtrTransportChannelMarker,
        >(
            (data,),
            0xba66b9de6960dd2,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<QrtrTransportChannelMarker>("write")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for QrtrTransportChannelProxy {
    type Protocol = QrtrTransportChannelMarker;

    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 QrtrTransportChannelProxy {
    /// Create a new Proxy for fuchsia.hardware.qualcomm.router/QrtrTransportChannel.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <QrtrTransportChannelMarker 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) -> QrtrTransportChannelEventStream {
        QrtrTransportChannelEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Reads a QRTR frame from a transport driver.
    ///
    /// Blocks until an inbound frame is ready to be consumed.
    /// Only one read request can be performed at a time.
    /// - `data`: QRTR frame.
    /// * Errors:
    ///   - `ALREADY_PENDING`: More than one read operation is pending.
    ///   - `INTERNAL_ERROR`: Unexpected QRTR error.
    pub fn r#read(
        &self,
    ) -> fidl::client::QueryResponseFut<
        QrtrTransportChannelReadResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        QrtrTransportChannelProxyInterface::r#read(self)
    }

    /// Writes a QRTR frame to a transport driver.
    ///
    /// Only one write request can be performed at a time.
    /// * Errors:
    ///   - `ALREADY_PENDING`: More than one write operation is pending.
    ///   - `INTERNAL_ERROR`: Unexpected QRTR error.
    pub fn r#write(
        &self,
        mut data: &[u8],
    ) -> fidl::client::QueryResponseFut<
        QrtrTransportChannelWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        QrtrTransportChannelProxyInterface::r#write(self, data)
    }
}

impl QrtrTransportChannelProxyInterface for QrtrTransportChannelProxy {
    type ReadResponseFut = fidl::client::QueryResponseFut<
        QrtrTransportChannelReadResult,
        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<QrtrTransportChannelReadResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<QrtrTransportChannelReadResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ea3f950c311b3e9,
            >(_buf?)?
            .into_result::<QrtrTransportChannelMarker>("read")?;
            Ok(_response.map(|x| x.data))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, QrtrTransportChannelReadResult>(
                (),
                0x1ea3f950c311b3e9,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type WriteResponseFut = fidl::client::QueryResponseFut<
        QrtrTransportChannelWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write(&self, mut data: &[u8]) -> Self::WriteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<QrtrTransportChannelWriteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xba66b9de6960dd2,
            >(_buf?)?
            .into_result::<QrtrTransportChannelMarker>("write")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            QrtrTransportChannelWriteRequest,
            QrtrTransportChannelWriteResult,
        >(
            (data,),
            0xba66b9de6960dd2,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for QrtrTransportChannelRequestStream {
    type Protocol = QrtrTransportChannelMarker;
    type ControlHandle = QrtrTransportChannelControlHandle;

    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 {
        QrtrTransportChannelControlHandle { 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 QrtrTransportChannelRequestStream {
    type Item = Result<QrtrTransportChannelRequest, 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 QrtrTransportChannelRequestStream 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 {
                0x1ea3f950c311b3e9 => {
                    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 = QrtrTransportChannelControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(QrtrTransportChannelRequest::Read {
                        responder: QrtrTransportChannelReadResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0xba66b9de6960dd2 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(QrtrTransportChannelWriteRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<QrtrTransportChannelWriteRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = QrtrTransportChannelControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(QrtrTransportChannelRequest::Write {data: req.data,

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

/// The channel for a transport driver that communicates with the remote
/// processor and the QRTR driver.
///
/// Every message is preambled by a QRTR header, consult the appropriate
/// specification for format.
#[derive(Debug)]
pub enum QrtrTransportChannelRequest {
    /// Reads a QRTR frame from a transport driver.
    ///
    /// Blocks until an inbound frame is ready to be consumed.
    /// Only one read request can be performed at a time.
    /// - `data`: QRTR frame.
    /// * Errors:
    ///   - `ALREADY_PENDING`: More than one read operation is pending.
    ///   - `INTERNAL_ERROR`: Unexpected QRTR error.
    Read { responder: QrtrTransportChannelReadResponder },
    /// Writes a QRTR frame to a transport driver.
    ///
    /// Only one write request can be performed at a time.
    /// * Errors:
    ///   - `ALREADY_PENDING`: More than one write operation is pending.
    ///   - `INTERNAL_ERROR`: Unexpected QRTR error.
    Write { data: Vec<u8>, responder: QrtrTransportChannelWriteResponder },
    /// 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: QrtrTransportChannelControlHandle,
        method_type: fidl::MethodType,
    },
}

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_write(self) -> Option<(Vec<u8>, QrtrTransportChannelWriteResponder)> {
        if let QrtrTransportChannelRequest::Write { data, responder } = self {
            Some((data, responder))
        } else {
            None
        }
    }

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

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl QrtrTransportChannelControlHandle {}

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for QrtrTransportConnectorMarker {
    type Proxy = QrtrTransportConnectorProxy;
    type RequestStream = QrtrTransportConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = QrtrTransportConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.hardware.qualcomm.router.QrtrTransportConnector";
}
impl fidl::endpoints::DiscoverableProtocolMarker for QrtrTransportConnectorMarker {}
pub type QrtrTransportConnectorEstablishConnectionResult = Result<(), Error>;

pub trait QrtrTransportConnectorProxyInterface: Send + Sync {
    type EstablishConnectionResponseFut: std::future::Future<
            Output = Result<QrtrTransportConnectorEstablishConnectionResult, fidl::Error>,
        > + Send;
    fn r#establish_connection(
        &self,
        options: &TransportConnectionOptions,
        proxy: fidl::endpoints::ClientEnd<QrtrTransportChannelMarker>,
    ) -> Self::EstablishConnectionResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct QrtrTransportConnectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for QrtrTransportConnectorSynchronousProxy {
    type Proxy = QrtrTransportConnectorProxy;
    type Protocol = QrtrTransportConnectorMarker;

    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 QrtrTransportConnectorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Establishes a channel.
    ///
    /// Child drivers should only establish one connection to the QRTR driver.
    pub fn r#establish_connection(
        &self,
        mut options: &TransportConnectionOptions,
        mut proxy: fidl::endpoints::ClientEnd<QrtrTransportChannelMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<QrtrTransportConnectorEstablishConnectionResult, fidl::Error> {
        let _response = self.client.send_query::<
            QrtrTransportConnectorEstablishConnectionRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            QrtrTransportConnectorMarker,
        >(
            (options, proxy,),
            0xd19f34bea9b6c17,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<QrtrTransportConnectorMarker>("establish_connection")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for QrtrTransportConnectorProxy {
    type Protocol = QrtrTransportConnectorMarker;

    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 QrtrTransportConnectorProxy {
    /// Create a new Proxy for fuchsia.hardware.qualcomm.router/QrtrTransportConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <QrtrTransportConnectorMarker 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) -> QrtrTransportConnectorEventStream {
        QrtrTransportConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Establishes a channel.
    ///
    /// Child drivers should only establish one connection to the QRTR driver.
    pub fn r#establish_connection(
        &self,
        mut options: &TransportConnectionOptions,
        mut proxy: fidl::endpoints::ClientEnd<QrtrTransportChannelMarker>,
    ) -> fidl::client::QueryResponseFut<
        QrtrTransportConnectorEstablishConnectionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        QrtrTransportConnectorProxyInterface::r#establish_connection(self, options, proxy)
    }
}

impl QrtrTransportConnectorProxyInterface for QrtrTransportConnectorProxy {
    type EstablishConnectionResponseFut = fidl::client::QueryResponseFut<
        QrtrTransportConnectorEstablishConnectionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#establish_connection(
        &self,
        mut options: &TransportConnectionOptions,
        mut proxy: fidl::endpoints::ClientEnd<QrtrTransportChannelMarker>,
    ) -> Self::EstablishConnectionResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<QrtrTransportConnectorEstablishConnectionResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xd19f34bea9b6c17,
            >(_buf?)?
            .into_result::<QrtrTransportConnectorMarker>("establish_connection")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            QrtrTransportConnectorEstablishConnectionRequest,
            QrtrTransportConnectorEstablishConnectionResult,
        >(
            (options, proxy,),
            0xd19f34bea9b6c17,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for QrtrTransportConnectorRequestStream {
    type Protocol = QrtrTransportConnectorMarker;
    type ControlHandle = QrtrTransportConnectorControlHandle;

    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 {
        QrtrTransportConnectorControlHandle { 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 QrtrTransportConnectorRequestStream {
    type Item = Result<QrtrTransportConnectorRequest, 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 QrtrTransportConnectorRequestStream 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 {
                0xd19f34bea9b6c17 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(QrtrTransportConnectorEstablishConnectionRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<QrtrTransportConnectorEstablishConnectionRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = QrtrTransportConnectorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(QrtrTransportConnectorRequest::EstablishConnection {options: req.options,
proxy: req.proxy,

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

/// Used by a transport driver that communicates with a remote processor
/// to establish a new channel to the QRTR driver.
#[derive(Debug)]
pub enum QrtrTransportConnectorRequest {
    /// Establishes a channel.
    ///
    /// Child drivers should only establish one connection to the QRTR driver.
    EstablishConnection {
        options: TransportConnectionOptions,
        proxy: fidl::endpoints::ClientEnd<QrtrTransportChannelMarker>,
        responder: QrtrTransportConnectorEstablishConnectionResponder,
    },
    /// 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: QrtrTransportConnectorControlHandle,
        method_type: fidl::MethodType,
    },
}

impl QrtrTransportConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_establish_connection(
        self,
    ) -> Option<(
        TransportConnectionOptions,
        fidl::endpoints::ClientEnd<QrtrTransportChannelMarker>,
        QrtrTransportConnectorEstablishConnectionResponder,
    )> {
        if let QrtrTransportConnectorRequest::EstablishConnection { options, proxy, responder } =
            self
        {
            Some((options, proxy, responder))
        } else {
            None
        }
    }

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

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

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

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

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl QrtrTransportConnectorControlHandle {}

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

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

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

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for ClientServiceMarker {
    type Proxy = ClientServiceProxy;
    type Request = ClientServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.qualcomm.router.ClientService";
}

/// A request for one of the member protocols of ClientService.
///
#[cfg(target_os = "fuchsia")]
pub enum ClientServiceRequest {
    QrtrConnector(QrtrConnectorRequestStream),
}

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

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

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

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

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

#[cfg(target_os = "fuchsia")]
impl ClientServiceProxy {
    pub fn connect_to_qrtr_connector(&self) -> Result<QrtrConnectorProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<QrtrConnectorMarker>();
        self.connect_channel_to_qrtr_connector(server_end)?;
        Ok(proxy)
    }

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

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

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for TransportServiceMarker {
    type Proxy = TransportServiceProxy;
    type Request = TransportServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.qualcomm.router.TransportService";
}

/// A request for one of the member protocols of TransportService.
///
#[cfg(target_os = "fuchsia")]
pub enum TransportServiceRequest {
    QrtrTransportConnector(QrtrTransportConnectorRequestStream),
}

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

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

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

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

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

#[cfg(target_os = "fuchsia")]
impl TransportServiceProxy {
    pub fn connect_to_qrtr_transport_connector(
        &self,
    ) -> Result<QrtrTransportConnectorProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<QrtrTransportConnectorMarker>();
        self.connect_channel_to_qrtr_transport_connector(server_end)?;
        Ok(proxy)
    }

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

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

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

mod internal {
    use super::*;

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

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

    impl fidl::encoding::ResourceTypeMarker for QrtrConnectorGetConnectionRequest {
        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 QrtrConnectorGetConnectionRequest {
        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<
            QrtrConnectorGetConnectionRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut QrtrConnectorGetConnectionRequest
    {
        #[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::<QrtrConnectorGetConnectionRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                QrtrConnectorGetConnectionRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <ConnectionOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<QrtrClientConnectionMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.proxy
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<ConnectionOptions, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<QrtrClientConnectionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            QrtrConnectorGetConnectionRequest,
            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::<QrtrConnectorGetConnectionRequest>(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 QrtrConnectorGetConnectionRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                options: fidl::new_empty!(
                    ConnectionOptions,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                proxy: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<QrtrClientConnectionMarker>,
                    >,
                    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!(
                ConnectionOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.options,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<QrtrClientConnectionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.proxy,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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