fidl_fuchsia_hardware_google_nanohub/

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DataChannelRegisterRequest {
    pub event: fidl::Event,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceDownloadFirmwareRequest {
    pub firmware: fidl::Vmo,
    pub offset: u64,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct DataChannelReadResponse {
    pub data: Option<Vec<u8>>,
    pub wake_lease: Option<fidl::EventPair>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct HangingDataChannelReadResponse {
    pub data: Option<Vec<u8>>,
    pub wake_lease: Option<fidl::EventPair>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct UnboundHangingDataChannelBindRequest {
    pub server: Option<fidl::endpoints::ServerEnd<HangingDataChannelMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct UnboundWaitableDataChannelBindRequest {
    pub event: Option<fidl::Event>,
    pub server: Option<fidl::endpoints::ServerEnd<WaitableDataChannelMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct WaitableDataChannelReadResponse {
    pub data: Option<Vec<u8>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

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

impl fidl::endpoints::ProtocolMarker for DataChannelMarker {
    type Proxy = DataChannelProxy;
    type RequestStream = DataChannelRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DataChannelSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) DataChannel";
}
pub type DataChannelRegisterResult = Result<(), i32>;
pub type DataChannelReadResult = Result<DataChannelReadResponse, i32>;
pub type DataChannelWriteResult = Result<(), i32>;

pub trait DataChannelProxyInterface: Send + Sync {
    type RegisterResponseFut: std::future::Future<Output = Result<DataChannelRegisterResult, fidl::Error>>
        + Send;
    fn r#register(&self, event: fidl::Event) -> Self::RegisterResponseFut;
    type GetIdentifierResponseFut: std::future::Future<Output = Result<DataChannelGetIdentifierResponse, fidl::Error>>
        + Send;
    fn r#get_identifier(&self) -> Self::GetIdentifierResponseFut;
    type ReadResponseFut: std::future::Future<Output = Result<DataChannelReadResult, fidl::Error>>
        + Send;
    fn r#read(&self, payload: &DataChannelReadRequest) -> Self::ReadResponseFut;
    type WriteResponseFut: std::future::Future<Output = Result<DataChannelWriteResult, fidl::Error>>
        + Send;
    fn r#write(&self, payload: &DataChannelWriteRequest) -> Self::WriteResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DataChannelSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DataChannelSynchronousProxy {
    type Proxy = DataChannelProxy;
    type Protocol = DataChannelMarker;

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

    /// Set event used to signal device state. Discards existing event
    /// after having transferred device state to the new event.
    /// This must be called before invoking Read or Write, and can fail with
    /// ZX_ERR_NO_RESOURCES if the underlying channel is busy.
    pub fn r#register(
        &self,
        mut event: fidl::Event,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DataChannelRegisterResult, fidl::Error> {
        let _response = self.client.send_query::<
            DataChannelRegisterRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
            DataChannelMarker,
        >(
            (event,),
            0x1778251ad75157b6,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<DataChannelMarker>("register")?;
        Ok(_response.map(|x| x))
    }

    /// Returns the identifier associated with this connection.
    pub fn r#get_identifier(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DataChannelGetIdentifierResponse, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<DataChannelGetIdentifierResponse>,
            DataChannelMarker,
        >(
            (),
            0x4bf148d0ddbd4f69,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<DataChannelMarker>("get_identifier")?;
        Ok(_response)
    }

    /// The call will return the next datagram to be read from the channel.
    /// If there is more data to be read, SIGNAL_READABLE will remain asserted
    /// after this call returns.
    pub fn r#read(
        &self,
        mut payload: &DataChannelReadRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DataChannelReadResult, fidl::Error> {
        let _response = self.client.send_query::<
            DataChannelReadRequest,
            fidl::encoding::FlexibleResultType<DataChannelReadResponse, i32>,
            DataChannelMarker,
        >(
            payload,
            0x12ab08cf21533d26,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<DataChannelMarker>("read")?;
        Ok(_response.map(|x| x))
    }

    /// The call will return once the data is fully committed.
    ///
    /// If the driver is not ready for a write, it will return
    /// ZX_ERR_NO_RESOURCES and the caller should await SIGNAL_WRITABLE to be
    /// asserted.
    pub fn r#write(
        &self,
        mut payload: &DataChannelWriteRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DataChannelWriteResult, fidl::Error> {
        let _response = self.client.send_query::<
            DataChannelWriteRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
            DataChannelMarker,
        >(
            payload,
            0xf2e12121698789b,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<DataChannelMarker>("write")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DataChannelProxy {
    type Protocol = DataChannelMarker;

    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 DataChannelProxy {
    /// Create a new Proxy for fuchsia.hardware.google.nanohub/DataChannel.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DataChannelMarker 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) -> DataChannelEventStream {
        DataChannelEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Set event used to signal device state. Discards existing event
    /// after having transferred device state to the new event.
    /// This must be called before invoking Read or Write, and can fail with
    /// ZX_ERR_NO_RESOURCES if the underlying channel is busy.
    pub fn r#register(
        &self,
        mut event: fidl::Event,
    ) -> fidl::client::QueryResponseFut<
        DataChannelRegisterResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DataChannelProxyInterface::r#register(self, event)
    }

    /// Returns the identifier associated with this connection.
    pub fn r#get_identifier(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DataChannelGetIdentifierResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DataChannelProxyInterface::r#get_identifier(self)
    }

    /// The call will return the next datagram to be read from the channel.
    /// If there is more data to be read, SIGNAL_READABLE will remain asserted
    /// after this call returns.
    pub fn r#read(
        &self,
        mut payload: &DataChannelReadRequest,
    ) -> fidl::client::QueryResponseFut<
        DataChannelReadResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DataChannelProxyInterface::r#read(self, payload)
    }

    /// The call will return once the data is fully committed.
    ///
    /// If the driver is not ready for a write, it will return
    /// ZX_ERR_NO_RESOURCES and the caller should await SIGNAL_WRITABLE to be
    /// asserted.
    pub fn r#write(
        &self,
        mut payload: &DataChannelWriteRequest,
    ) -> fidl::client::QueryResponseFut<
        DataChannelWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DataChannelProxyInterface::r#write(self, payload)
    }
}

impl DataChannelProxyInterface for DataChannelProxy {
    type RegisterResponseFut = fidl::client::QueryResponseFut<
        DataChannelRegisterResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#register(&self, mut event: fidl::Event) -> Self::RegisterResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DataChannelRegisterResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1778251ad75157b6,
            >(_buf?)?
            .into_result::<DataChannelMarker>("register")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DataChannelRegisterRequest, DataChannelRegisterResult>(
            (event,),
            0x1778251ad75157b6,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

    type ReadResponseFut = fidl::client::QueryResponseFut<
        DataChannelReadResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read(&self, mut payload: &DataChannelReadRequest) -> Self::ReadResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DataChannelReadResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<DataChannelReadResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x12ab08cf21533d26,
            >(_buf?)?
            .into_result::<DataChannelMarker>("read")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DataChannelReadRequest, DataChannelReadResult>(
            payload,
            0x12ab08cf21533d26,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DataChannelRequestStream {
    type Protocol = DataChannelMarker;
    type ControlHandle = DataChannelControlHandle;

    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 {
        DataChannelControlHandle { 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 DataChannelRequestStream {
    type Item = Result<DataChannelRequest, 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 DataChannelRequestStream 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 {
                    0x1778251ad75157b6 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataChannelRegisterRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataChannelRegisterRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DataChannelControlHandle { inner: this.inner.clone() };
                        Ok(DataChannelRequest::Register {
                            event: req.event,

                            responder: DataChannelRegisterResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4bf148d0ddbd4f69 => {
                        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 = DataChannelControlHandle { inner: this.inner.clone() };
                        Ok(DataChannelRequest::GetIdentifier {
                            responder: DataChannelGetIdentifierResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x12ab08cf21533d26 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataChannelReadRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataChannelReadRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DataChannelControlHandle { inner: this.inner.clone() };
                        Ok(DataChannelRequest::Read {
                            payload: req,
                            responder: DataChannelReadResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xf2e12121698789b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DataChannelWriteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DataChannelWriteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DataChannelControlHandle { inner: this.inner.clone() };
                        Ok(DataChannelRequest::Write {
                            payload: req,
                            responder: DataChannelWriteResponder {
                                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(DataChannelRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: DataChannelControlHandle { 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(DataChannelRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: DataChannelControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DataChannelMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// DataChannel Implementation
#[derive(Debug)]
pub enum DataChannelRequest {
    /// Set event used to signal device state. Discards existing event
    /// after having transferred device state to the new event.
    /// This must be called before invoking Read or Write, and can fail with
    /// ZX_ERR_NO_RESOURCES if the underlying channel is busy.
    Register { event: fidl::Event, responder: DataChannelRegisterResponder },
    /// Returns the identifier associated with this connection.
    GetIdentifier { responder: DataChannelGetIdentifierResponder },
    /// The call will return the next datagram to be read from the channel.
    /// If there is more data to be read, SIGNAL_READABLE will remain asserted
    /// after this call returns.
    Read { payload: DataChannelReadRequest, responder: DataChannelReadResponder },
    /// The call will return once the data is fully committed.
    ///
    /// If the driver is not ready for a write, it will return
    /// ZX_ERR_NO_RESOURCES and the caller should await SIGNAL_WRITABLE to be
    /// asserted.
    Write { payload: DataChannelWriteRequest, responder: DataChannelWriteResponder },
    /// 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: DataChannelControlHandle,
        method_type: fidl::MethodType,
    },
}

impl DataChannelRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_register(self) -> Option<(fidl::Event, DataChannelRegisterResponder)> {
        if let DataChannelRequest::Register { event, responder } = self {
            Some((event, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_identifier(self) -> Option<(DataChannelGetIdentifierResponder)> {
        if let DataChannelRequest::GetIdentifier { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read(self) -> Option<(DataChannelReadRequest, DataChannelReadResponder)> {
        if let DataChannelRequest::Read { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<DataChannelReadResponse, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleResultType<DataChannelReadResponse, i32>>(
                fidl::encoding::FlexibleResult::new(result.as_mut().map_err(|e| *e)),
                self.tx_id,
                0x12ab08cf21533d26,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for DeviceMarker {
    type Proxy = DeviceProxy;
    type RequestStream = DeviceRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DeviceSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.hardware.google.nanohub.Device";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DeviceMarker {}
pub type DeviceDownloadFirmwareResult = Result<(), i32>;
pub type DeviceGetTimeSyncResult = Result<McuTimeSyncInfo, i32>;
pub type DeviceSetWakeLockResult = Result<(), i32>;
pub type DeviceGetWakeUpEventDurationResult = Result<i64, i32>;
pub type DeviceSetWakeUpEventDurationResult = Result<(), i32>;
pub type DeviceHardwareResetResult = Result<(), i32>;

pub trait DeviceProxyInterface: Send + Sync {
    type DownloadFirmwareResponseFut: std::future::Future<Output = Result<DeviceDownloadFirmwareResult, fidl::Error>>
        + Send;
    fn r#download_firmware(
        &self,
        firmware: fidl::Vmo,
        offset: u64,
    ) -> Self::DownloadFirmwareResponseFut;
    type GetFirmwareNameResponseFut: std::future::Future<Output = Result<String, fidl::Error>>
        + Send;
    fn r#get_firmware_name(&self) -> Self::GetFirmwareNameResponseFut;
    type GetFirmwareVersionResponseFut: std::future::Future<Output = Result<McuVersionInfo, fidl::Error>>
        + Send;
    fn r#get_firmware_version(&self) -> Self::GetFirmwareVersionResponseFut;
    type GetTimeSyncResponseFut: std::future::Future<Output = Result<DeviceGetTimeSyncResult, fidl::Error>>
        + Send;
    fn r#get_time_sync(&self) -> Self::GetTimeSyncResponseFut;
    type SetWakeLockResponseFut: std::future::Future<Output = Result<DeviceSetWakeLockResult, fidl::Error>>
        + Send;
    fn r#set_wake_lock(&self, value: McuWakeLockValue) -> Self::SetWakeLockResponseFut;
    type GetWakeUpEventDurationResponseFut: std::future::Future<Output = Result<DeviceGetWakeUpEventDurationResult, fidl::Error>>
        + Send;
    fn r#get_wake_up_event_duration(&self) -> Self::GetWakeUpEventDurationResponseFut;
    type SetWakeUpEventDurationResponseFut: std::future::Future<Output = Result<DeviceSetWakeUpEventDurationResult, fidl::Error>>
        + Send;
    fn r#set_wake_up_event_duration(
        &self,
        duration: i64,
    ) -> Self::SetWakeUpEventDurationResponseFut;
    type HardwareResetResponseFut: std::future::Future<Output = Result<DeviceHardwareResetResult, fidl::Error>>
        + Send;
    fn r#hardware_reset(
        &self,
        isp_pin_0: PinState,
        isp_pin_1: PinState,
        isp_pin_2: PinState,
    ) -> Self::HardwareResetResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DeviceSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DeviceSynchronousProxy {
    type Proxy = DeviceProxy;
    type Protocol = DeviceMarker;

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

    /// Request to sent to nanohub to load the firmware.
    pub fn r#download_firmware(
        &self,
        mut firmware: fidl::Vmo,
        mut offset: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceDownloadFirmwareResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceDownloadFirmwareRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMarker,
        >(
            (firmware, offset,),
            0x7bba8137e24661e5,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// The name of the firmware binary running on the MCU.
    pub fn r#get_firmware_name(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<String, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            DeviceGetFirmwareNameResponse,
            DeviceMarker,
        >(
            (),
            0x1649434b5e5bcb8d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.firmware_name)
    }

    /// The version of the firmware binary running on the MCU.
    pub fn r#get_firmware_version(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<McuVersionInfo, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            DeviceGetFirmwareVersionResponse,
            DeviceMarker,
        >(
            (),
            0x4f0599abcc95736b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.version_info)
    }

    /// The time since boot recorded by the AP and the MCU.
    pub fn r#get_time_sync(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceGetTimeSyncResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<McuTimeSyncInfo, i32>,
            DeviceMarker,
        >(
            (),
            0x4406991222e3975d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Set an MCU wake lock request to prevent the MCU from entering a low-power state.
    pub fn r#set_wake_lock(
        &self,
        mut value: McuWakeLockValue,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceSetWakeLockResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceSetWakeLockRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMarker,
        >(
            (value,),
            0x9f83f614affa1dc,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get the current duration of time the MCU will remain awake.
    pub fn r#get_wake_up_event_duration(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceGetWakeUpEventDurationResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<DeviceGetWakeUpEventDurationResponse, i32>,
            DeviceMarker,
        >(
            (),
            0x45c79749f65e7176,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.duration))
    }

    /// Set a duration of time for the MCU to remain awake.
    pub fn r#set_wake_up_event_duration(
        &self,
        mut duration: i64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceSetWakeUpEventDurationResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceSetWakeUpEventDurationRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMarker,
        >(
            (duration,),
            0x1fa1771ffa5f570,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Initiates a hardware reset.
    pub fn r#hardware_reset(
        &self,
        mut isp_pin_0: PinState,
        mut isp_pin_1: PinState,
        mut isp_pin_2: PinState,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceHardwareResetResult, fidl::Error> {
        let _response = self.client.send_query::<
            HardwareResetPinStates,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMarker,
        >(
            (isp_pin_0, isp_pin_1, isp_pin_2,),
            0x78e3d2ded2f929f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DeviceProxy {
    type Protocol = DeviceMarker;

    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 DeviceProxy {
    /// Create a new Proxy for fuchsia.hardware.google.nanohub/Device.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DeviceMarker 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) -> DeviceEventStream {
        DeviceEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Request to sent to nanohub to load the firmware.
    pub fn r#download_firmware(
        &self,
        mut firmware: fidl::Vmo,
        mut offset: u64,
    ) -> fidl::client::QueryResponseFut<
        DeviceDownloadFirmwareResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#download_firmware(self, firmware, offset)
    }

    /// The name of the firmware binary running on the MCU.
    pub fn r#get_firmware_name(
        &self,
    ) -> fidl::client::QueryResponseFut<String, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DeviceProxyInterface::r#get_firmware_name(self)
    }

    /// The version of the firmware binary running on the MCU.
    pub fn r#get_firmware_version(
        &self,
    ) -> fidl::client::QueryResponseFut<McuVersionInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        DeviceProxyInterface::r#get_firmware_version(self)
    }

    /// The time since boot recorded by the AP and the MCU.
    pub fn r#get_time_sync(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DeviceGetTimeSyncResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#get_time_sync(self)
    }

    /// Set an MCU wake lock request to prevent the MCU from entering a low-power state.
    pub fn r#set_wake_lock(
        &self,
        mut value: McuWakeLockValue,
    ) -> fidl::client::QueryResponseFut<
        DeviceSetWakeLockResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#set_wake_lock(self, value)
    }

    /// Get the current duration of time the MCU will remain awake.
    pub fn r#get_wake_up_event_duration(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DeviceGetWakeUpEventDurationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#get_wake_up_event_duration(self)
    }

    /// Set a duration of time for the MCU to remain awake.
    pub fn r#set_wake_up_event_duration(
        &self,
        mut duration: i64,
    ) -> fidl::client::QueryResponseFut<
        DeviceSetWakeUpEventDurationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#set_wake_up_event_duration(self, duration)
    }

    /// Initiates a hardware reset.
    pub fn r#hardware_reset(
        &self,
        mut isp_pin_0: PinState,
        mut isp_pin_1: PinState,
        mut isp_pin_2: PinState,
    ) -> fidl::client::QueryResponseFut<
        DeviceHardwareResetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#hardware_reset(self, isp_pin_0, isp_pin_1, isp_pin_2)
    }
}

impl DeviceProxyInterface for DeviceProxy {
    type DownloadFirmwareResponseFut = fidl::client::QueryResponseFut<
        DeviceDownloadFirmwareResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#download_firmware(
        &self,
        mut firmware: fidl::Vmo,
        mut offset: u64,
    ) -> Self::DownloadFirmwareResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceDownloadFirmwareResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7bba8137e24661e5,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<DeviceDownloadFirmwareRequest, DeviceDownloadFirmwareResult>(
                (firmware, offset),
                0x7bba8137e24661e5,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

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

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

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

    type SetWakeLockResponseFut = fidl::client::QueryResponseFut<
        DeviceSetWakeLockResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_wake_lock(&self, mut value: McuWakeLockValue) -> Self::SetWakeLockResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceSetWakeLockResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x9f83f614affa1dc,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<DeviceSetWakeLockRequest, DeviceSetWakeLockResult>(
            (value,),
            0x9f83f614affa1dc,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type SetWakeUpEventDurationResponseFut = fidl::client::QueryResponseFut<
        DeviceSetWakeUpEventDurationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_wake_up_event_duration(
        &self,
        mut duration: i64,
    ) -> Self::SetWakeUpEventDurationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceSetWakeUpEventDurationResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1fa1771ffa5f570,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DeviceSetWakeUpEventDurationRequest,
            DeviceSetWakeUpEventDurationResult,
        >(
            (duration,),
            0x1fa1771ffa5f570,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type HardwareResetResponseFut = fidl::client::QueryResponseFut<
        DeviceHardwareResetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#hardware_reset(
        &self,
        mut isp_pin_0: PinState,
        mut isp_pin_1: PinState,
        mut isp_pin_2: PinState,
    ) -> Self::HardwareResetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceHardwareResetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x78e3d2ded2f929f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<HardwareResetPinStates, DeviceHardwareResetResult>(
            (isp_pin_0, isp_pin_1, isp_pin_2),
            0x78e3d2ded2f929f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DeviceRequestStream {
    type Protocol = DeviceMarker;
    type ControlHandle = DeviceControlHandle;

    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 {
        DeviceControlHandle { 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 DeviceRequestStream {
    type Item = Result<DeviceRequest, 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 DeviceRequestStream 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 {
                    0x7bba8137e24661e5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceDownloadFirmwareRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceDownloadFirmwareRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::DownloadFirmware {
                            firmware: req.firmware,
                            offset: req.offset,

                            responder: DeviceDownloadFirmwareResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1649434b5e5bcb8d => {
                        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 = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetFirmwareName {
                            responder: DeviceGetFirmwareNameResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4f0599abcc95736b => {
                        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 = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetFirmwareVersion {
                            responder: DeviceGetFirmwareVersionResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4406991222e3975d => {
                        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 = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetTimeSync {
                            responder: DeviceGetTimeSyncResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x9f83f614affa1dc => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceSetWakeLockRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceSetWakeLockRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::SetWakeLock {
                            value: req.value,

                            responder: DeviceSetWakeLockResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x45c79749f65e7176 => {
                        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 = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetWakeUpEventDuration {
                            responder: DeviceGetWakeUpEventDurationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1fa1771ffa5f570 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceSetWakeUpEventDurationRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceSetWakeUpEventDurationRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::SetWakeUpEventDuration {
                            duration: req.duration,

                            responder: DeviceSetWakeUpEventDurationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x78e3d2ded2f929f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            HardwareResetPinStates,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HardwareResetPinStates>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::HardwareReset {
                            isp_pin_0: req.isp_pin_0,
                            isp_pin_1: req.isp_pin_1,
                            isp_pin_2: req.isp_pin_2,

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

/// Client is expected to pass the vmo handle to nanohub when issuing a DownloadFirmware request.
#[derive(Debug)]
pub enum DeviceRequest {
    /// Request to sent to nanohub to load the firmware.
    DownloadFirmware {
        firmware: fidl::Vmo,
        offset: u64,
        responder: DeviceDownloadFirmwareResponder,
    },
    /// The name of the firmware binary running on the MCU.
    GetFirmwareName { responder: DeviceGetFirmwareNameResponder },
    /// The version of the firmware binary running on the MCU.
    GetFirmwareVersion { responder: DeviceGetFirmwareVersionResponder },
    /// The time since boot recorded by the AP and the MCU.
    GetTimeSync { responder: DeviceGetTimeSyncResponder },
    /// Set an MCU wake lock request to prevent the MCU from entering a low-power state.
    SetWakeLock { value: McuWakeLockValue, responder: DeviceSetWakeLockResponder },
    /// Get the current duration of time the MCU will remain awake.
    GetWakeUpEventDuration { responder: DeviceGetWakeUpEventDurationResponder },
    /// Set a duration of time for the MCU to remain awake.
    SetWakeUpEventDuration { duration: i64, responder: DeviceSetWakeUpEventDurationResponder },
    /// Initiates a hardware reset.
    HardwareReset {
        isp_pin_0: PinState,
        isp_pin_1: PinState,
        isp_pin_2: PinState,
        responder: DeviceHardwareResetResponder,
    },
    /// 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: DeviceControlHandle,
        method_type: fidl::MethodType,
    },
}

impl DeviceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_download_firmware(
        self,
    ) -> Option<(fidl::Vmo, u64, DeviceDownloadFirmwareResponder)> {
        if let DeviceRequest::DownloadFirmware { firmware, offset, responder } = self {
            Some((firmware, offset, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_firmware_name(self) -> Option<(DeviceGetFirmwareNameResponder)> {
        if let DeviceRequest::GetFirmwareName { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_firmware_version(self) -> Option<(DeviceGetFirmwareVersionResponder)> {
        if let DeviceRequest::GetFirmwareVersion { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_time_sync(self) -> Option<(DeviceGetTimeSyncResponder)> {
        if let DeviceRequest::GetTimeSync { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_wake_lock(self) -> Option<(McuWakeLockValue, DeviceSetWakeLockResponder)> {
        if let DeviceRequest::SetWakeLock { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_wake_up_event_duration(
        self,
    ) -> Option<(DeviceGetWakeUpEventDurationResponder)> {
        if let DeviceRequest::GetWakeUpEventDuration { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_wake_up_event_duration(
        self,
    ) -> Option<(i64, DeviceSetWakeUpEventDurationResponder)> {
        if let DeviceRequest::SetWakeUpEventDuration { duration, responder } = self {
            Some((duration, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_hardware_reset(
        self,
    ) -> Option<(PinState, PinState, PinState, DeviceHardwareResetResponder)> {
        if let DeviceRequest::HardwareReset { isp_pin_0, isp_pin_1, isp_pin_2, responder } = self {
            Some((isp_pin_0, isp_pin_1, isp_pin_2, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DeviceRequest::DownloadFirmware { .. } => "download_firmware",
            DeviceRequest::GetFirmwareName { .. } => "get_firmware_name",
            DeviceRequest::GetFirmwareVersion { .. } => "get_firmware_version",
            DeviceRequest::GetTimeSync { .. } => "get_time_sync",
            DeviceRequest::SetWakeLock { .. } => "set_wake_lock",
            DeviceRequest::GetWakeUpEventDuration { .. } => "get_wake_up_event_duration",
            DeviceRequest::SetWakeUpEventDuration { .. } => "set_wake_up_event_duration",
            DeviceRequest::HardwareReset { .. } => "hardware_reset",
            DeviceRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            DeviceRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut firmware_name: &str) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceGetFirmwareNameResponse>(
            (firmware_name,),
            self.tx_id,
            0x1649434b5e5bcb8d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut version_info: &McuVersionInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceGetFirmwareVersionResponse>(
            (version_info,),
            self.tx_id,
            0x4f0599abcc95736b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<i64, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            DeviceGetWakeUpEventDurationResponse,
            i32,
        >>(
            result.map(|duration| (duration,)),
            self.tx_id,
            0x45c79749f65e7176,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for DisplayDeviceMarker {
    type Proxy = DisplayDeviceProxy;
    type RequestStream = DisplayDeviceRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DisplayDeviceSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.hardware.google.nanohub.DisplayDevice";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DisplayDeviceMarker {}
pub type DisplayDeviceGetDisplayStateResult = Result<DisplayState, i32>;
pub type DisplayDeviceGetDisplayInfoResult = Result<DisplaySyncInfo, i32>;
pub type DisplayDeviceGetDisplaySelectResult = Result<DisplayDeviceGetDisplaySelectResponse, i32>;
pub type DisplayDeviceSetDisplaySelectResult = Result<(), i32>;

pub trait DisplayDeviceProxyInterface: Send + Sync {
    type GetDisplayStateResponseFut: std::future::Future<Output = Result<DisplayDeviceGetDisplayStateResult, fidl::Error>>
        + Send;
    fn r#get_display_state(&self) -> Self::GetDisplayStateResponseFut;
    type GetDisplayInfoResponseFut: std::future::Future<Output = Result<DisplayDeviceGetDisplayInfoResult, fidl::Error>>
        + Send;
    fn r#get_display_info(&self) -> Self::GetDisplayInfoResponseFut;
    type GetDisplaySelectResponseFut: std::future::Future<Output = Result<DisplayDeviceGetDisplaySelectResult, fidl::Error>>
        + Send;
    fn r#get_display_select(&self) -> Self::GetDisplaySelectResponseFut;
    type SetDisplaySelectResponseFut: std::future::Future<Output = Result<DisplayDeviceSetDisplaySelectResult, fidl::Error>>
        + Send;
    fn r#set_display_select(
        &self,
        payload: &DisplayDeviceSetDisplaySelectRequest,
    ) -> Self::SetDisplaySelectResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DisplayDeviceSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DisplayDeviceSynchronousProxy {
    type Proxy = DisplayDeviceProxy;
    type Protocol = DisplayDeviceMarker;

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

    /// Gets the current state of the display.
    pub fn r#get_display_state(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DisplayDeviceGetDisplayStateResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<DisplayState, i32>,
            DisplayDeviceMarker,
        >(
            (),
            0x1648924f6e003444,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Gets synchronization information for the display. This can include
    /// the display's mode, panel mode, and brightness levels.
    pub fn r#get_display_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DisplayDeviceGetDisplayInfoResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<DisplaySyncInfo, i32>,
            DisplayDeviceMarker,
        >(
            (),
            0x311c8e4cb6b1b4d1,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Gets the current display owner, which is either the AP (Application
    /// Processor) or the MCU (Microcontroller Unit).
    pub fn r#get_display_select(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DisplayDeviceGetDisplaySelectResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<DisplayDeviceGetDisplaySelectResponse, i32>,
            DisplayDeviceMarker,
        >(
            (),
            0x6191c86cffd6323,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Sets the display owner to be either the AP (Application Processor) or
    /// the MCU (Microcontroller Unit).
    pub fn r#set_display_select(
        &self,
        mut payload: &DisplayDeviceSetDisplaySelectRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DisplayDeviceSetDisplaySelectResult, fidl::Error> {
        let _response = self.client.send_query::<
            DisplayDeviceSetDisplaySelectRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DisplayDeviceMarker,
        >(
            payload,
            0x2b07f6ba12e7a412,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DisplayDeviceProxy {
    type Protocol = DisplayDeviceMarker;

    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 DisplayDeviceProxy {
    /// Create a new Proxy for fuchsia.hardware.google.nanohub/DisplayDevice.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DisplayDeviceMarker 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) -> DisplayDeviceEventStream {
        DisplayDeviceEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Gets the current state of the display.
    pub fn r#get_display_state(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DisplayDeviceGetDisplayStateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DisplayDeviceProxyInterface::r#get_display_state(self)
    }

    /// Gets synchronization information for the display. This can include
    /// the display's mode, panel mode, and brightness levels.
    pub fn r#get_display_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DisplayDeviceGetDisplayInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DisplayDeviceProxyInterface::r#get_display_info(self)
    }

    /// Gets the current display owner, which is either the AP (Application
    /// Processor) or the MCU (Microcontroller Unit).
    pub fn r#get_display_select(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DisplayDeviceGetDisplaySelectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DisplayDeviceProxyInterface::r#get_display_select(self)
    }

    /// Sets the display owner to be either the AP (Application Processor) or
    /// the MCU (Microcontroller Unit).
    pub fn r#set_display_select(
        &self,
        mut payload: &DisplayDeviceSetDisplaySelectRequest,
    ) -> fidl::client::QueryResponseFut<
        DisplayDeviceSetDisplaySelectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DisplayDeviceProxyInterface::r#set_display_select(self, payload)
    }
}

impl DisplayDeviceProxyInterface for DisplayDeviceProxy {
    type GetDisplayStateResponseFut = fidl::client::QueryResponseFut<
        DisplayDeviceGetDisplayStateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_display_state(&self) -> Self::GetDisplayStateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DisplayDeviceGetDisplayStateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<DisplayState, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1648924f6e003444,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            DisplayDeviceGetDisplayStateResult,
        >(
            (),
            0x1648924f6e003444,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DisplayDeviceRequestStream {
    type Protocol = DisplayDeviceMarker;
    type ControlHandle = DisplayDeviceControlHandle;

    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 {
        DisplayDeviceControlHandle { 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 DisplayDeviceRequestStream {
    type Item = Result<DisplayDeviceRequest, 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 DisplayDeviceRequestStream 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 {
                    0x1648924f6e003444 => {
                        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 =
                            DisplayDeviceControlHandle { inner: this.inner.clone() };
                        Ok(DisplayDeviceRequest::GetDisplayState {
                            responder: DisplayDeviceGetDisplayStateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x311c8e4cb6b1b4d1 => {
                        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 =
                            DisplayDeviceControlHandle { inner: this.inner.clone() };
                        Ok(DisplayDeviceRequest::GetDisplayInfo {
                            responder: DisplayDeviceGetDisplayInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6191c86cffd6323 => {
                        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 =
                            DisplayDeviceControlHandle { inner: this.inner.clone() };
                        Ok(DisplayDeviceRequest::GetDisplaySelect {
                            responder: DisplayDeviceGetDisplaySelectResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2b07f6ba12e7a412 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DisplayDeviceSetDisplaySelectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DisplayDeviceSetDisplaySelectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DisplayDeviceControlHandle { inner: this.inner.clone() };
                        Ok(DisplayDeviceRequest::SetDisplaySelect {
                            payload: req,
                            responder: DisplayDeviceSetDisplaySelectResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DisplayDeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol for interacting with the Google-specific display hardware.
#[derive(Debug)]
pub enum DisplayDeviceRequest {
    /// Gets the current state of the display.
    GetDisplayState { responder: DisplayDeviceGetDisplayStateResponder },
    /// Gets synchronization information for the display. This can include
    /// the display's mode, panel mode, and brightness levels.
    GetDisplayInfo { responder: DisplayDeviceGetDisplayInfoResponder },
    /// Gets the current display owner, which is either the AP (Application
    /// Processor) or the MCU (Microcontroller Unit).
    GetDisplaySelect { responder: DisplayDeviceGetDisplaySelectResponder },
    /// Sets the display owner to be either the AP (Application Processor) or
    /// the MCU (Microcontroller Unit).
    SetDisplaySelect {
        payload: DisplayDeviceSetDisplaySelectRequest,
        responder: DisplayDeviceSetDisplaySelectResponder,
    },
}

impl DisplayDeviceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_display_state(self) -> Option<(DisplayDeviceGetDisplayStateResponder)> {
        if let DisplayDeviceRequest::GetDisplayState { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_display_info(self) -> Option<(DisplayDeviceGetDisplayInfoResponder)> {
        if let DisplayDeviceRequest::GetDisplayInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_display_select(self) -> Option<(DisplayDeviceGetDisplaySelectResponder)> {
        if let DisplayDeviceRequest::GetDisplaySelect { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_display_select(
        self,
    ) -> Option<(DisplayDeviceSetDisplaySelectRequest, DisplayDeviceSetDisplaySelectResponder)>
    {
        if let DisplayDeviceRequest::SetDisplaySelect { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DisplayDeviceRequest::GetDisplayState { .. } => "get_display_state",
            DisplayDeviceRequest::GetDisplayInfo { .. } => "get_display_info",
            DisplayDeviceRequest::GetDisplaySelect { .. } => "get_display_select",
            DisplayDeviceRequest::SetDisplaySelect { .. } => "set_display_select",
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for HangingDataChannelMarker {
    type Proxy = HangingDataChannelProxy;
    type RequestStream = HangingDataChannelRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = HangingDataChannelSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) HangingDataChannel";
}
pub type HangingDataChannelReadResult = Result<HangingDataChannelReadResponse, i32>;
pub type HangingDataChannelWriteResult = Result<(), i32>;

pub trait HangingDataChannelProxyInterface: Send + Sync {
    type ReadResponseFut: std::future::Future<Output = Result<HangingDataChannelReadResult, fidl::Error>>
        + Send;
    fn r#read(&self) -> Self::ReadResponseFut;
    type WriteResponseFut: std::future::Future<Output = Result<HangingDataChannelWriteResult, fidl::Error>>
        + Send;
    fn r#write(&self, payload: &HangingDataChannelWriteRequest) -> Self::WriteResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct HangingDataChannelSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for HangingDataChannelSynchronousProxy {
    type Proxy = HangingDataChannelProxy;
    type Protocol = HangingDataChannelMarker;

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

    /// The call will return the next datagram to be read from the channel.
    /// This call has hanging get semantics and will return once data is available.
    pub fn r#read(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HangingDataChannelReadResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<HangingDataChannelReadResponse, i32>,
            HangingDataChannelMarker,
        >(
            (),
            0x160be10337c2484f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<HangingDataChannelMarker>("read")?;
        Ok(_response.map(|x| x))
    }

    /// The call will return once the data is fully committed.
    ///
    /// If the driver is not ready for a write, it will return
    /// ZX_ERR_NO_RESOURCES
    pub fn r#write(
        &self,
        mut payload: &HangingDataChannelWriteRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<HangingDataChannelWriteResult, fidl::Error> {
        let _response = self.client.send_query::<
            HangingDataChannelWriteRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
            HangingDataChannelMarker,
        >(
            payload,
            0x6addfd084eb16746,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<HangingDataChannelMarker>("write")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for HangingDataChannelProxy {
    type Protocol = HangingDataChannelMarker;

    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 HangingDataChannelProxy {
    /// Create a new Proxy for fuchsia.hardware.google.nanohub/HangingDataChannel.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <HangingDataChannelMarker 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) -> HangingDataChannelEventStream {
        HangingDataChannelEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// The call will return the next datagram to be read from the channel.
    /// This call has hanging get semantics and will return once data is available.
    pub fn r#read(
        &self,
    ) -> fidl::client::QueryResponseFut<
        HangingDataChannelReadResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        HangingDataChannelProxyInterface::r#read(self)
    }

    /// The call will return once the data is fully committed.
    ///
    /// If the driver is not ready for a write, it will return
    /// ZX_ERR_NO_RESOURCES
    pub fn r#write(
        &self,
        mut payload: &HangingDataChannelWriteRequest,
    ) -> fidl::client::QueryResponseFut<
        HangingDataChannelWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        HangingDataChannelProxyInterface::r#write(self, payload)
    }
}

impl HangingDataChannelProxyInterface for HangingDataChannelProxy {
    type ReadResponseFut = fidl::client::QueryResponseFut<
        HangingDataChannelReadResult,
        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<HangingDataChannelReadResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<HangingDataChannelReadResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x160be10337c2484f,
            >(_buf?)?
            .into_result::<HangingDataChannelMarker>("read")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, HangingDataChannelReadResult>(
                (),
                0x160be10337c2484f,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for HangingDataChannelRequestStream {
    type Protocol = HangingDataChannelMarker;
    type ControlHandle = HangingDataChannelControlHandle;

    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 {
        HangingDataChannelControlHandle { 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 HangingDataChannelRequestStream {
    type Item = Result<HangingDataChannelRequest, 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 HangingDataChannelRequestStream 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 {
                0x160be10337c2484f => {
                    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 = HangingDataChannelControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(HangingDataChannelRequest::Read {
                        responder: HangingDataChannelReadResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6addfd084eb16746 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(HangingDataChannelWriteRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<HangingDataChannelWriteRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = HangingDataChannelControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(HangingDataChannelRequest::Write {payload: req,
                        responder: HangingDataChannelWriteResponder {
                            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(HangingDataChannelRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: HangingDataChannelControlHandle { 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(HangingDataChannelRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: HangingDataChannelControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <HangingDataChannelMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Provides a bound / connected session to a particular DataChannel. New connections should use the
/// UnboundHangingDataChannel to open a session of this procotol.
/// Calls to Read() on a HangingDataChannel will operate as a Hanging-Get, only returning once data
/// becomes available.
#[derive(Debug)]
pub enum HangingDataChannelRequest {
    /// The call will return the next datagram to be read from the channel.
    /// This call has hanging get semantics and will return once data is available.
    Read { responder: HangingDataChannelReadResponder },
    /// The call will return once the data is fully committed.
    ///
    /// If the driver is not ready for a write, it will return
    /// ZX_ERR_NO_RESOURCES
    Write { payload: HangingDataChannelWriteRequest, responder: HangingDataChannelWriteResponder },
    /// 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: HangingDataChannelControlHandle,
        method_type: fidl::MethodType,
    },
}

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

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

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<HangingDataChannelReadResponse, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            HangingDataChannelReadResponse,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result.as_mut().map_err(|e| *e)),
            self.tx_id,
            0x160be10337c2484f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for LifecycleObserverMarker {
    type Proxy = LifecycleObserverProxy;
    type RequestStream = LifecycleObserverRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = LifecycleObserverSynchronousProxy;

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for LifecycleObserverSynchronousProxy {
    type Proxy = LifecycleObserverProxy;
    type Protocol = LifecycleObserverMarker;

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

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

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

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

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

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

impl fidl::endpoints::Proxy for LifecycleObserverProxy {
    type Protocol = LifecycleObserverMarker;

    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 LifecycleObserverProxy {
    /// Create a new Proxy for fuchsia.hardware.google.nanohub/LifecycleObserver.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <LifecycleObserverMarker 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) -> LifecycleObserverEventStream {
        LifecycleObserverEventStream { event_receiver: self.client.take_event_receiver() }
    }
}

impl LifecycleObserverProxyInterface for LifecycleObserverProxy {}

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

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

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

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

#[derive(Debug)]
pub enum LifecycleObserverEvent {
    OnLifecycleChange { event: LifecycleEvent },
}

impl LifecycleObserverEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_lifecycle_change(self) -> Option<LifecycleEvent> {
        if let LifecycleObserverEvent::OnLifecycleChange { event } = self {
            Some((event))
        } else {
            None
        }
    }

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

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

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

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

impl fidl::endpoints::RequestStream for LifecycleObserverRequestStream {
    type Protocol = LifecycleObserverMarker;
    type ControlHandle = LifecycleObserverControlHandle;

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

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

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

/// Observer interface for lifecycle events.
#[derive(Debug)]
pub enum LifecycleObserverRequest {}

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

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

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

impl fidl::endpoints::ControlHandle for LifecycleObserverControlHandle {
    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 LifecycleObserverControlHandle {
    pub fn send_on_lifecycle_change(&self, mut event: LifecycleEvent) -> Result<(), fidl::Error> {
        self.inner.send::<LifecycleObserverOnLifecycleChangeRequest>(
            (event,),
            0,
            0x7034eb94979bd8de,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for UnboundHangingDataChannelMarker {
    type Proxy = UnboundHangingDataChannelProxy;
    type RequestStream = UnboundHangingDataChannelRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = UnboundHangingDataChannelSynchronousProxy;

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

pub trait UnboundHangingDataChannelProxyInterface: Send + Sync {
    type BindResponseFut: std::future::Future<Output = Result<UnboundHangingDataChannelBindResult, fidl::Error>>
        + Send;
    fn r#bind(&self, payload: UnboundHangingDataChannelBindRequest) -> Self::BindResponseFut;
    type GetIdentifierResponseFut: std::future::Future<
            Output = Result<UnboundHangingDataChannelGetIdentifierResponse, fidl::Error>,
        > + Send;
    fn r#get_identifier(&self) -> Self::GetIdentifierResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct UnboundHangingDataChannelSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for UnboundHangingDataChannelSynchronousProxy {
    type Proxy = UnboundHangingDataChannelProxy;
    type Protocol = UnboundHangingDataChannelMarker;

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

    /// Returns a bound client
    /// Will return ZX_ERR_ALREADY_BOUND if no instances are available
    pub fn r#bind(
        &self,
        mut payload: UnboundHangingDataChannelBindRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<UnboundHangingDataChannelBindResult, fidl::Error> {
        let _response = self.client.send_query::<
            UnboundHangingDataChannelBindRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
            UnboundHangingDataChannelMarker,
        >(
            &mut payload,
            0x62be1ffca6ea4090,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<UnboundHangingDataChannelMarker>("bind")?;
        Ok(_response.map(|x| x))
    }

    /// Returns the identifier associated with this connection.
    pub fn r#get_identifier(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<UnboundHangingDataChannelGetIdentifierResponse, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<UnboundHangingDataChannelGetIdentifierResponse>,
            UnboundHangingDataChannelMarker,
        >(
            (),
            0x63d3f258532f3b0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<UnboundHangingDataChannelMarker>("get_identifier")?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for UnboundHangingDataChannelProxy {
    type Protocol = UnboundHangingDataChannelMarker;

    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 UnboundHangingDataChannelProxy {
    /// Create a new Proxy for fuchsia.hardware.google.nanohub/UnboundHangingDataChannel.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <UnboundHangingDataChannelMarker 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) -> UnboundHangingDataChannelEventStream {
        UnboundHangingDataChannelEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns a bound client
    /// Will return ZX_ERR_ALREADY_BOUND if no instances are available
    pub fn r#bind(
        &self,
        mut payload: UnboundHangingDataChannelBindRequest,
    ) -> fidl::client::QueryResponseFut<
        UnboundHangingDataChannelBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        UnboundHangingDataChannelProxyInterface::r#bind(self, payload)
    }

    /// Returns the identifier associated with this connection.
    pub fn r#get_identifier(
        &self,
    ) -> fidl::client::QueryResponseFut<
        UnboundHangingDataChannelGetIdentifierResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        UnboundHangingDataChannelProxyInterface::r#get_identifier(self)
    }
}

impl UnboundHangingDataChannelProxyInterface for UnboundHangingDataChannelProxy {
    type BindResponseFut = fidl::client::QueryResponseFut<
        UnboundHangingDataChannelBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#bind(&self, mut payload: UnboundHangingDataChannelBindRequest) -> Self::BindResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<UnboundHangingDataChannelBindResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x62be1ffca6ea4090,
            >(_buf?)?
            .into_result::<UnboundHangingDataChannelMarker>("bind")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            UnboundHangingDataChannelBindRequest,
            UnboundHangingDataChannelBindResult,
        >(
            &mut payload,
            0x62be1ffca6ea4090,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for UnboundHangingDataChannelRequestStream {
    type Protocol = UnboundHangingDataChannelMarker;
    type ControlHandle = UnboundHangingDataChannelControlHandle;

    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 {
        UnboundHangingDataChannelControlHandle { 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 UnboundHangingDataChannelRequestStream {
    type Item = Result<UnboundHangingDataChannelRequest, 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 UnboundHangingDataChannelRequestStream 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 {
                0x62be1ffca6ea4090 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(UnboundHangingDataChannelBindRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnboundHangingDataChannelBindRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = UnboundHangingDataChannelControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(UnboundHangingDataChannelRequest::Bind {payload: req,
                        responder: UnboundHangingDataChannelBindResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x63d3f258532f3b0 => {
                    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 = UnboundHangingDataChannelControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(UnboundHangingDataChannelRequest::GetIdentifier {
                        responder: UnboundHangingDataChannelGetIdentifierResponder {
                            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(UnboundHangingDataChannelRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: UnboundHangingDataChannelControlHandle { 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(UnboundHangingDataChannelRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: UnboundHangingDataChannelControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <UnboundHangingDataChannelMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

#[derive(Debug)]
pub enum UnboundHangingDataChannelRequest {
    /// Returns a bound client
    /// Will return ZX_ERR_ALREADY_BOUND if no instances are available
    Bind {
        payload: UnboundHangingDataChannelBindRequest,
        responder: UnboundHangingDataChannelBindResponder,
    },
    /// Returns the identifier associated with this connection.
    GetIdentifier { responder: UnboundHangingDataChannelGetIdentifierResponder },
    /// 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: UnboundHangingDataChannelControlHandle,
        method_type: fidl::MethodType,
    },
}

impl UnboundHangingDataChannelRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_bind(
        self,
    ) -> Option<(UnboundHangingDataChannelBindRequest, UnboundHangingDataChannelBindResponder)>
    {
        if let UnboundHangingDataChannelRequest::Bind { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_identifier(self) -> Option<(UnboundHangingDataChannelGetIdentifierResponder)> {
        if let UnboundHangingDataChannelRequest::GetIdentifier { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for UnboundWaitableDataChannelMarker {
    type Proxy = UnboundWaitableDataChannelProxy;
    type RequestStream = UnboundWaitableDataChannelRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = UnboundWaitableDataChannelSynchronousProxy;

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

pub trait UnboundWaitableDataChannelProxyInterface: Send + Sync {
    type BindResponseFut: std::future::Future<Output = Result<UnboundWaitableDataChannelBindResult, fidl::Error>>
        + Send;
    fn r#bind(&self, payload: UnboundWaitableDataChannelBindRequest) -> Self::BindResponseFut;
    type GetIdentifierResponseFut: std::future::Future<
            Output = Result<UnboundWaitableDataChannelGetIdentifierResponse, fidl::Error>,
        > + Send;
    fn r#get_identifier(&self) -> Self::GetIdentifierResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct UnboundWaitableDataChannelSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for UnboundWaitableDataChannelSynchronousProxy {
    type Proxy = UnboundWaitableDataChannelProxy;
    type Protocol = UnboundWaitableDataChannelMarker;

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

    /// Set event used to signal device state, using the signals above,
    /// and returns a bound client.
    /// Will return ZX_ERR_ALREADY_BOUND if no instances are available.
    pub fn r#bind(
        &self,
        mut payload: UnboundWaitableDataChannelBindRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<UnboundWaitableDataChannelBindResult, fidl::Error> {
        let _response = self.client.send_query::<
            UnboundWaitableDataChannelBindRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
            UnboundWaitableDataChannelMarker,
        >(
            &mut payload,
            0x135713194412491e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<UnboundWaitableDataChannelMarker>("bind")?;
        Ok(_response.map(|x| x))
    }

    /// Returns the identifier associated with this connection.
    pub fn r#get_identifier(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<UnboundWaitableDataChannelGetIdentifierResponse, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<UnboundWaitableDataChannelGetIdentifierResponse>,
            UnboundWaitableDataChannelMarker,
        >(
            (),
            0x6a36e55ac6beb9d6,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<UnboundWaitableDataChannelMarker>("get_identifier")?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for UnboundWaitableDataChannelProxy {
    type Protocol = UnboundWaitableDataChannelMarker;

    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 UnboundWaitableDataChannelProxy {
    /// Create a new Proxy for fuchsia.hardware.google.nanohub/UnboundWaitableDataChannel.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <UnboundWaitableDataChannelMarker 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) -> UnboundWaitableDataChannelEventStream {
        UnboundWaitableDataChannelEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Set event used to signal device state, using the signals above,
    /// and returns a bound client.
    /// Will return ZX_ERR_ALREADY_BOUND if no instances are available.
    pub fn r#bind(
        &self,
        mut payload: UnboundWaitableDataChannelBindRequest,
    ) -> fidl::client::QueryResponseFut<
        UnboundWaitableDataChannelBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        UnboundWaitableDataChannelProxyInterface::r#bind(self, payload)
    }

    /// Returns the identifier associated with this connection.
    pub fn r#get_identifier(
        &self,
    ) -> fidl::client::QueryResponseFut<
        UnboundWaitableDataChannelGetIdentifierResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        UnboundWaitableDataChannelProxyInterface::r#get_identifier(self)
    }
}

impl UnboundWaitableDataChannelProxyInterface for UnboundWaitableDataChannelProxy {
    type BindResponseFut = fidl::client::QueryResponseFut<
        UnboundWaitableDataChannelBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#bind(&self, mut payload: UnboundWaitableDataChannelBindRequest) -> Self::BindResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<UnboundWaitableDataChannelBindResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x135713194412491e,
            >(_buf?)?
            .into_result::<UnboundWaitableDataChannelMarker>("bind")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            UnboundWaitableDataChannelBindRequest,
            UnboundWaitableDataChannelBindResult,
        >(
            &mut payload,
            0x135713194412491e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for UnboundWaitableDataChannelRequestStream {
    type Protocol = UnboundWaitableDataChannelMarker;
    type ControlHandle = UnboundWaitableDataChannelControlHandle;

    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 {
        UnboundWaitableDataChannelControlHandle { 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 UnboundWaitableDataChannelRequestStream {
    type Item = Result<UnboundWaitableDataChannelRequest, 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 UnboundWaitableDataChannelRequestStream 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 {
                0x135713194412491e => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(UnboundWaitableDataChannelBindRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnboundWaitableDataChannelBindRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = UnboundWaitableDataChannelControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(UnboundWaitableDataChannelRequest::Bind {payload: req,
                        responder: UnboundWaitableDataChannelBindResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6a36e55ac6beb9d6 => {
                    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 = UnboundWaitableDataChannelControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(UnboundWaitableDataChannelRequest::GetIdentifier {
                        responder: UnboundWaitableDataChannelGetIdentifierResponder {
                            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(UnboundWaitableDataChannelRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: UnboundWaitableDataChannelControlHandle { 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(UnboundWaitableDataChannelRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: UnboundWaitableDataChannelControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <UnboundWaitableDataChannelMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Provides both service instance disambiguation as well as a notion of a disconnected data channel
/// via bind interface. Callers should use this protocol to acquire a bound WaitableDataChannel.
#[derive(Debug)]
pub enum UnboundWaitableDataChannelRequest {
    /// Set event used to signal device state, using the signals above,
    /// and returns a bound client.
    /// Will return ZX_ERR_ALREADY_BOUND if no instances are available.
    Bind {
        payload: UnboundWaitableDataChannelBindRequest,
        responder: UnboundWaitableDataChannelBindResponder,
    },
    /// Returns the identifier associated with this connection.
    GetIdentifier { responder: UnboundWaitableDataChannelGetIdentifierResponder },
    /// 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: UnboundWaitableDataChannelControlHandle,
        method_type: fidl::MethodType,
    },
}

impl UnboundWaitableDataChannelRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_bind(
        self,
    ) -> Option<(UnboundWaitableDataChannelBindRequest, UnboundWaitableDataChannelBindResponder)>
    {
        if let UnboundWaitableDataChannelRequest::Bind { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_identifier(self) -> Option<(UnboundWaitableDataChannelGetIdentifierResponder)> {
        if let UnboundWaitableDataChannelRequest::GetIdentifier { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for WaitableDataChannelMarker {
    type Proxy = WaitableDataChannelProxy;
    type RequestStream = WaitableDataChannelRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = WaitableDataChannelSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) WaitableDataChannel";
}
pub type WaitableDataChannelReadResult = Result<WaitableDataChannelReadResponse, i32>;
pub type WaitableDataChannelWriteResult = Result<(), i32>;

pub trait WaitableDataChannelProxyInterface: Send + Sync {
    type ReadResponseFut: std::future::Future<Output = Result<WaitableDataChannelReadResult, fidl::Error>>
        + Send;
    fn r#read(&self) -> Self::ReadResponseFut;
    type WriteResponseFut: std::future::Future<Output = Result<WaitableDataChannelWriteResult, fidl::Error>>
        + Send;
    fn r#write(&self, payload: &WaitableDataChannelWriteRequest) -> Self::WriteResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct WaitableDataChannelSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for WaitableDataChannelSynchronousProxy {
    type Proxy = WaitableDataChannelProxy;
    type Protocol = WaitableDataChannelMarker;

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

    /// The call will return the next datagram to be read from the channel.
    /// If there is more data to be read, SIGNAL_READABLE will remain asserted
    /// after this call returns.
    /// If there is no data to be read, this call will return ZX_ERR_SHOULD_WAIT
    pub fn r#read(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WaitableDataChannelReadResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<WaitableDataChannelReadResponse, i32>,
            WaitableDataChannelMarker,
        >(
            (),
            0x48f55df455309245,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<WaitableDataChannelMarker>("read")?;
        Ok(_response.map(|x| x))
    }

    /// The call will return once the data is fully committed.
    ///
    /// If the driver is not ready for a write, it will return
    /// ZX_ERR_NO_RESOURCES and the caller should await SIGNAL_WRITABLE to be
    /// asserted.
    pub fn r#write(
        &self,
        mut payload: &WaitableDataChannelWriteRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WaitableDataChannelWriteResult, fidl::Error> {
        let _response = self.client.send_query::<
            WaitableDataChannelWriteRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
            WaitableDataChannelMarker,
        >(
            payload,
            0x6d9b754b0e3122f2,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<WaitableDataChannelMarker>("write")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for WaitableDataChannelProxy {
    type Protocol = WaitableDataChannelMarker;

    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 WaitableDataChannelProxy {
    /// Create a new Proxy for fuchsia.hardware.google.nanohub/WaitableDataChannel.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <WaitableDataChannelMarker 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) -> WaitableDataChannelEventStream {
        WaitableDataChannelEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// The call will return the next datagram to be read from the channel.
    /// If there is more data to be read, SIGNAL_READABLE will remain asserted
    /// after this call returns.
    /// If there is no data to be read, this call will return ZX_ERR_SHOULD_WAIT
    pub fn r#read(
        &self,
    ) -> fidl::client::QueryResponseFut<
        WaitableDataChannelReadResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WaitableDataChannelProxyInterface::r#read(self)
    }

    /// The call will return once the data is fully committed.
    ///
    /// If the driver is not ready for a write, it will return
    /// ZX_ERR_NO_RESOURCES and the caller should await SIGNAL_WRITABLE to be
    /// asserted.
    pub fn r#write(
        &self,
        mut payload: &WaitableDataChannelWriteRequest,
    ) -> fidl::client::QueryResponseFut<
        WaitableDataChannelWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        WaitableDataChannelProxyInterface::r#write(self, payload)
    }
}

impl WaitableDataChannelProxyInterface for WaitableDataChannelProxy {
    type ReadResponseFut = fidl::client::QueryResponseFut<
        WaitableDataChannelReadResult,
        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<WaitableDataChannelReadResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<WaitableDataChannelReadResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x48f55df455309245,
            >(_buf?)?
            .into_result::<WaitableDataChannelMarker>("read")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, WaitableDataChannelReadResult>(
                (),
                0x48f55df455309245,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for WaitableDataChannelRequestStream {
    type Protocol = WaitableDataChannelMarker;
    type ControlHandle = WaitableDataChannelControlHandle;

    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 {
        WaitableDataChannelControlHandle { 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 WaitableDataChannelRequestStream {
    type Item = Result<WaitableDataChannelRequest, 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 WaitableDataChannelRequestStream 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 {
                0x48f55df455309245 => {
                    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 = WaitableDataChannelControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(WaitableDataChannelRequest::Read {
                        responder: WaitableDataChannelReadResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6d9b754b0e3122f2 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(WaitableDataChannelWriteRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WaitableDataChannelWriteRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = WaitableDataChannelControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(WaitableDataChannelRequest::Write {payload: req,
                        responder: WaitableDataChannelWriteResponder {
                            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(WaitableDataChannelRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: WaitableDataChannelControlHandle { 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(WaitableDataChannelRequest::_UnknownMethod {
                        ordinal: header.ordinal,
                        control_handle: WaitableDataChannelControlHandle { inner: this.inner.clone() },
                        method_type: fidl::MethodType::TwoWay,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <WaitableDataChannelMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Provides a bound / connected session to a particular DataChannel. New connections should use the
/// UnboundWaitableDataChannel to open a session of this procotol.
/// Calls to Read() on a WaitableDataChannel will operate as a non-blocking operation. Callers
/// will need to use the event exchanged in the Bind() call to flag when data is available to read
#[derive(Debug)]
pub enum WaitableDataChannelRequest {
    /// The call will return the next datagram to be read from the channel.
    /// If there is more data to be read, SIGNAL_READABLE will remain asserted
    /// after this call returns.
    /// If there is no data to be read, this call will return ZX_ERR_SHOULD_WAIT
    Read { responder: WaitableDataChannelReadResponder },
    /// The call will return once the data is fully committed.
    ///
    /// If the driver is not ready for a write, it will return
    /// ZX_ERR_NO_RESOURCES and the caller should await SIGNAL_WRITABLE to be
    /// asserted.
    Write { payload: WaitableDataChannelWriteRequest, responder: WaitableDataChannelWriteResponder },
    /// 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: WaitableDataChannelControlHandle,
        method_type: fidl::MethodType,
    },
}

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

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

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<WaitableDataChannelReadResponse, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            WaitableDataChannelReadResponse,
            i32,
        >>(
            fidl::encoding::FlexibleResult::new(result.as_mut().map_err(|e| *e)),
            self.tx_id,
            0x48f55df455309245,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for DataChannelServiceMarker {
    type Proxy = DataChannelServiceProxy;
    type Request = DataChannelServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.google.nanohub.DataChannelService";
}

/// A request for one of the member protocols of DataChannelService.
///
/// Service for clients.
///
/// The data channel is pre-bound to a particular identifier as per bind rules.
#[cfg(target_os = "fuchsia")]
pub enum DataChannelServiceRequest {
    Device(DataChannelRequestStream),
    Lifecycle(LifecycleObserverRequestStream),
}

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

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

    fn member_names() -> &'static [&'static str] {
        &["device", "lifecycle"]
    }
}
/// Service for clients.
///
/// The data channel is pre-bound to a particular identifier as per bind rules.
#[cfg(target_os = "fuchsia")]
pub struct DataChannelServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

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

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

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

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

    /// Like `connect_to_device`, but accepts a server end.
    /// See [`Self::connect_to_device`] for more details.
    pub fn connect_channel_to_device(
        &self,
        server_end: fidl::endpoints::ServerEnd<DataChannelMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("device", server_end.into_channel())
    }
    pub fn connect_to_lifecycle(&self) -> Result<LifecycleObserverProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<LifecycleObserverMarker>();
        self.connect_channel_to_lifecycle(server_end)?;
        Ok(proxy)
    }

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

    /// Like `connect_to_lifecycle`, but accepts a server end.
    /// See [`Self::connect_to_lifecycle`] for more details.
    pub fn connect_channel_to_lifecycle(
        &self,
        server_end: fidl::endpoints::ServerEnd<LifecycleObserverMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("lifecycle", 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 DisplayServiceMarker;

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for DisplayServiceMarker {
    type Proxy = DisplayServiceProxy;
    type Request = DisplayServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.google.nanohub.DisplayService";
}

/// A request for one of the member protocols of DisplayService.
///
/// The service that provides access to the display device.
#[cfg(target_os = "fuchsia")]
pub enum DisplayServiceRequest {
    /// The display device.
    Mcudisplay(DisplayDeviceRequestStream),
}

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

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

    fn member_names() -> &'static [&'static str] {
        &["mcudisplay"]
    }
}
/// The service that provides access to the display device.
#[cfg(target_os = "fuchsia")]
pub struct DisplayServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

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

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

#[cfg(target_os = "fuchsia")]
impl DisplayServiceProxy {
    /// The display device.
    pub fn connect_to_mcudisplay(&self) -> Result<DisplayDeviceProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<DisplayDeviceMarker>();
        self.connect_channel_to_mcudisplay(server_end)?;
        Ok(proxy)
    }

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

    /// Like `connect_to_mcudisplay`, but accepts a server end.
    /// See [`Self::connect_to_mcudisplay`] for more details.
    pub fn connect_channel_to_mcudisplay(
        &self,
        server_end: fidl::endpoints::ServerEnd<DisplayDeviceMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("mcudisplay", 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 DriverDataChannelServiceMarker;

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for DriverDataChannelServiceMarker {
    type Proxy = DriverDataChannelServiceProxy;
    type Request = DriverDataChannelServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.google.nanohub.DriverDataChannelService";
}

/// A request for one of the member protocols of DriverDataChannelService.
///
/// Service for driver clients.
#[cfg(target_os = "fuchsia")]
pub enum DriverDataChannelServiceRequest {
    Hanging(UnboundHangingDataChannelRequestStream),
    Waitable(UnboundWaitableDataChannelRequestStream),
    Lifecycle(LifecycleObserverRequestStream),
}

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

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "hanging" => Self::Hanging(
                <UnboundHangingDataChannelRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            "waitable" => Self::Waitable(
                <UnboundWaitableDataChannelRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            "lifecycle" => Self::Lifecycle(
                <LifecycleObserverRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            _ => panic!("no such member protocol name for service DriverDataChannelService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["hanging", "waitable", "lifecycle"]
    }
}
/// Service for driver clients.
#[cfg(target_os = "fuchsia")]
pub struct DriverDataChannelServiceProxy(
    #[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>,
);

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

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

#[cfg(target_os = "fuchsia")]
impl DriverDataChannelServiceProxy {
    pub fn connect_to_hanging(&self) -> Result<UnboundHangingDataChannelProxy, fidl::Error> {
        let (proxy, server_end) =
            fidl::endpoints::create_proxy::<UnboundHangingDataChannelMarker>();
        self.connect_channel_to_hanging(server_end)?;
        Ok(proxy)
    }

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

    /// Like `connect_to_hanging`, but accepts a server end.
    /// See [`Self::connect_to_hanging`] for more details.
    pub fn connect_channel_to_hanging(
        &self,
        server_end: fidl::endpoints::ServerEnd<UnboundHangingDataChannelMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("hanging", server_end.into_channel())
    }
    pub fn connect_to_waitable(&self) -> Result<UnboundWaitableDataChannelProxy, fidl::Error> {
        let (proxy, server_end) =
            fidl::endpoints::create_proxy::<UnboundWaitableDataChannelMarker>();
        self.connect_channel_to_waitable(server_end)?;
        Ok(proxy)
    }

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

    /// Like `connect_to_waitable`, but accepts a server end.
    /// See [`Self::connect_to_waitable`] for more details.
    pub fn connect_channel_to_waitable(
        &self,
        server_end: fidl::endpoints::ServerEnd<UnboundWaitableDataChannelMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("waitable", server_end.into_channel())
    }
    pub fn connect_to_lifecycle(&self) -> Result<LifecycleObserverProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<LifecycleObserverMarker>();
        self.connect_channel_to_lifecycle(server_end)?;
        Ok(proxy)
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    /// Like `connect_to_nanohub`, but accepts a server end.
    /// See [`Self::connect_to_nanohub`] for more details.
    pub fn connect_channel_to_nanohub(
        &self,
        server_end: fidl::endpoints::ServerEnd<DeviceMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("nanohub", 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 StarnixDataChannelServiceMarker;

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for StarnixDataChannelServiceMarker {
    type Proxy = StarnixDataChannelServiceProxy;
    type Request = StarnixDataChannelServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.google.nanohub.StarnixDataChannelService";
}

/// A request for one of the member protocols of StarnixDataChannelService.
///
/// Service for Non-driver clients
/// Separated from Driver Service to allow for selectively exposing endpoints
#[cfg(target_os = "fuchsia")]
pub enum StarnixDataChannelServiceRequest {
    Hanging(UnboundHangingDataChannelRequestStream),
    Waitable(UnboundWaitableDataChannelRequestStream),
    Lifecycle(LifecycleObserverRequestStream),
}

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

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            "hanging" => Self::Hanging(
                <UnboundHangingDataChannelRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            "waitable" => Self::Waitable(
                <UnboundWaitableDataChannelRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            "lifecycle" => Self::Lifecycle(
                <LifecycleObserverRequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            _ => panic!("no such member protocol name for service StarnixDataChannelService"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &["hanging", "waitable", "lifecycle"]
    }
}
/// Service for Non-driver clients
/// Separated from Driver Service to allow for selectively exposing endpoints
#[cfg(target_os = "fuchsia")]
pub struct StarnixDataChannelServiceProxy(
    #[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>,
);

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

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

#[cfg(target_os = "fuchsia")]
impl StarnixDataChannelServiceProxy {
    pub fn connect_to_hanging(&self) -> Result<UnboundHangingDataChannelProxy, fidl::Error> {
        let (proxy, server_end) =
            fidl::endpoints::create_proxy::<UnboundHangingDataChannelMarker>();
        self.connect_channel_to_hanging(server_end)?;
        Ok(proxy)
    }

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

    /// Like `connect_to_hanging`, but accepts a server end.
    /// See [`Self::connect_to_hanging`] for more details.
    pub fn connect_channel_to_hanging(
        &self,
        server_end: fidl::endpoints::ServerEnd<UnboundHangingDataChannelMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("hanging", server_end.into_channel())
    }
    pub fn connect_to_waitable(&self) -> Result<UnboundWaitableDataChannelProxy, fidl::Error> {
        let (proxy, server_end) =
            fidl::endpoints::create_proxy::<UnboundWaitableDataChannelMarker>();
        self.connect_channel_to_waitable(server_end)?;
        Ok(proxy)
    }

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

    /// Like `connect_to_waitable`, but accepts a server end.
    /// See [`Self::connect_to_waitable`] for more details.
    pub fn connect_channel_to_waitable(
        &self,
        server_end: fidl::endpoints::ServerEnd<UnboundWaitableDataChannelMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("waitable", server_end.into_channel())
    }
    pub fn connect_to_lifecycle(&self) -> Result<LifecycleObserverProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<LifecycleObserverMarker>();
        self.connect_channel_to_lifecycle(server_end)?;
        Ok(proxy)
    }

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

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

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

mod internal {
    use super::*;

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DeviceDownloadFirmwareRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                firmware: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 49271>, fidl::encoding::DefaultFuchsiaResourceDialect),
                offset: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }
}