fidl_fuchsia_hardware_spi/

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ControllerOpenSessionRequest {
    pub session: fidl::endpoints::ServerEnd<DeviceMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TestConnectSpiLoopbackRequest {
    pub server: fidl::endpoints::ServerEnd<DeviceMarker>,
}

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

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

impl fidl::endpoints::ProtocolMarker for ControllerMarker {
    type Proxy = ControllerProxy;
    type RequestStream = ControllerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ControllerSynchronousProxy;

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

pub trait ControllerProxyInterface: Send + Sync {
    fn r#open_session(
        &self,
        session: fidl::endpoints::ServerEnd<DeviceMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ControllerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ControllerSynchronousProxy {
    type Proxy = ControllerProxy;
    type Protocol = ControllerMarker;

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

    /// Opens a new session on the device.
    ///
    /// At most one session is permitted at one time; the server end will be
    /// closed with `ZX_ERR_ALREADY_BOUND` if a session already exists.
    pub fn r#open_session(
        &self,
        mut session: fidl::endpoints::ServerEnd<DeviceMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ControllerOpenSessionRequest>(
            (session,),
            0x19d861074d409b34,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ControllerProxy {
    type Protocol = ControllerMarker;

    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 ControllerProxy {
    /// Create a new Proxy for fuchsia.hardware.spi/Controller.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ControllerMarker 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) -> ControllerEventStream {
        ControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Opens a new session on the device.
    ///
    /// At most one session is permitted at one time; the server end will be
    /// closed with `ZX_ERR_ALREADY_BOUND` if a session already exists.
    pub fn r#open_session(
        &self,
        mut session: fidl::endpoints::ServerEnd<DeviceMarker>,
    ) -> Result<(), fidl::Error> {
        ControllerProxyInterface::r#open_session(self, session)
    }
}

impl ControllerProxyInterface for ControllerProxy {
    fn r#open_session(
        &self,
        mut session: fidl::endpoints::ServerEnd<DeviceMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ControllerOpenSessionRequest>(
            (session,),
            0x19d861074d409b34,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ControllerRequestStream {
    type Protocol = ControllerMarker;
    type ControlHandle = ControllerControlHandle;

    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 {
        ControllerControlHandle { 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 ControllerRequestStream {
    type Item = Result<ControllerRequest, 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 ControllerRequestStream 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 {
                    0x19d861074d409b34 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ControllerOpenSessionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControllerOpenSessionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
                        Ok(ControllerRequest::OpenSession { session: req.session, control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum ControllerRequest {
    /// Opens a new session on the device.
    ///
    /// At most one session is permitted at one time; the server end will be
    /// closed with `ZX_ERR_ALREADY_BOUND` if a session already exists.
    OpenSession {
        session: fidl::endpoints::ServerEnd<DeviceMarker>,
        control_handle: ControllerControlHandle,
    },
}

impl ControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_open_session(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<DeviceMarker>, ControllerControlHandle)> {
        if let ControllerRequest::OpenSession { session, control_handle } = self {
            Some((session, control_handle))
        } else {
            None
        }
    }

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

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

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

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

#[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.spi.Device";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DeviceMarker {}

pub trait DeviceProxyInterface: Send + Sync {
    type TransmitResponseFut: std::future::Future<
            Output = Result<
                fidl_fuchsia_hardware_sharedmemory::SharedVmoIoTransmitResult,
                fidl::Error,
            >,
        > + Send;
    fn r#transmit(
        &self,
        buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
    ) -> Self::TransmitResponseFut;
    type ReceiveResponseFut: std::future::Future<
            Output = Result<
                fidl_fuchsia_hardware_sharedmemory::SharedVmoIoReceiveResult,
                fidl::Error,
            >,
        > + Send;
    fn r#receive(
        &self,
        buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
    ) -> Self::ReceiveResponseFut;
    type ExchangeResponseFut: std::future::Future<
            Output = Result<
                fidl_fuchsia_hardware_sharedmemory::SharedVmoIoExchangeResult,
                fidl::Error,
            >,
        > + Send;
    fn r#exchange(
        &self,
        tx_buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
        rx_buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
    ) -> Self::ExchangeResponseFut;
    type RegisterVmoResponseFut: std::future::Future<
            Output = Result<
                fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterRegisterVmoResult,
                fidl::Error,
            >,
        > + Send;
    fn r#register_vmo(
        &self,
        vmo_id: u32,
        vmo: fidl_fuchsia_mem::Range,
        rights: fidl_fuchsia_hardware_sharedmemory::SharedVmoRight,
    ) -> Self::RegisterVmoResponseFut;
    type UnregisterVmoResponseFut: std::future::Future<
            Output = Result<
                fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterUnregisterVmoResult,
                fidl::Error,
            >,
        > + Send;
    fn r#unregister_vmo(&self, vmo_id: u32) -> Self::UnregisterVmoResponseFut;
    type TransmitVectorResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#transmit_vector(&self, data: &[u8]) -> Self::TransmitVectorResponseFut;
    type ReceiveVectorResponseFut: std::future::Future<Output = Result<(i32, Vec<u8>), fidl::Error>>
        + Send;
    fn r#receive_vector(&self, size: u32) -> Self::ReceiveVectorResponseFut;
    type ExchangeVectorResponseFut: std::future::Future<Output = Result<(i32, Vec<u8>), fidl::Error>>
        + Send;
    fn r#exchange_vector(&self, txdata: &[u8]) -> Self::ExchangeVectorResponseFut;
    type CanAssertCsResponseFut: std::future::Future<Output = Result<bool, fidl::Error>> + Send;
    fn r#can_assert_cs(&self) -> Self::CanAssertCsResponseFut;
    type AssertCsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#assert_cs(&self) -> Self::AssertCsResponseFut;
    type DeassertCsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#deassert_cs(&self) -> Self::DeassertCsResponseFut;
}
#[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)?)
    }

    /// Sends the data in buffer to the device.
    pub fn r#transmit(
        &self,
        mut buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_hardware_sharedmemory::SharedVmoIoTransmitResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl_fuchsia_hardware_sharedmemory::SharedVmoIoTransmitRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMarker,
        >(
            (buffer,),
            0x791970e4c961b0bf,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Receives data from the device into buffer.
    pub fn r#receive(
        &self,
        mut buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_hardware_sharedmemory::SharedVmoIoReceiveResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl_fuchsia_hardware_sharedmemory::SharedVmoIoReceiveRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMarker,
        >(
            (buffer,),
            0x1c31986cc443db59,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Simultaneously transmits and receives data. The size fields of tx_buffer and rx_buffer must
    /// be the same.
    pub fn r#exchange(
        &self,
        mut tx_buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
        mut rx_buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_hardware_sharedmemory::SharedVmoIoExchangeResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl_fuchsia_hardware_sharedmemory::SharedVmoIoExchangeRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMarker,
        >(
            (tx_buffer, rx_buffer,),
            0x6ddad3b45d5deccc,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Registers a VMO and transfers ownership to the driver.
    /// vmo_id: The ID chosen by the client that will be used in operations on this VMO.
    /// vmo: The handle, offset, and size of this VMO. IO operations on this VMO will be relative to
    /// the offset and size specified here.
    /// rights: A bit field of SharedVmoRight values indicating how this VMO may be used. Callers
    /// should assume that the driver will map and/or pin the VMO using these rights.
    pub fn r#register_vmo(
        &self,
        mut vmo_id: u32,
        mut vmo: fidl_fuchsia_mem::Range,
        mut rights: fidl_fuchsia_hardware_sharedmemory::SharedVmoRight,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterRegisterVmoResult, fidl::Error>
    {
        let _response = self.client.send_query::<
            fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterRegisterVmoRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            DeviceMarker,
        >(
            (vmo_id, &mut vmo, rights,),
            0x31df51e1e6ea4a15,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Unmaps and/or unpins the VMO and returns the handle to the caller.
    pub fn r#unregister_vmo(
        &self,
        mut vmo_id: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterUnregisterVmoResult, fidl::Error>
    {
        let _response = self.client.send_query::<
            fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterUnregisterVmoRequest,
            fidl::encoding::ResultType<fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterUnregisterVmoResponse, i32>,
            DeviceMarker,
        >(
            (vmo_id,),
            0x1194e9b693827109,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.vmo))
    }

    /// Half-duplex transmit data to a SPI device; always transmits the entire buffer on success.
    pub fn r#transmit_vector(
        &self,
        mut data: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self
            .client
            .send_query::<DeviceTransmitVectorRequest, DeviceTransmitVectorResponse, DeviceMarker>(
                (data,),
                0x46a82725fcb5e5d2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Half-duplex receive data from a SPI device; always reads the full size requested.
    pub fn r#receive_vector(
        &self,
        mut size: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Vec<u8>), fidl::Error> {
        let _response = self
            .client
            .send_query::<DeviceReceiveVectorRequest, DeviceReceiveVectorResponse, DeviceMarker>(
                (size,),
                0x37b160ed6bdd3fd6,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.status, _response.data))
    }

    /// Full-duplex SPI transaction. Received data will exactly equal the length of the transmit
    /// buffer.
    pub fn r#exchange_vector(
        &self,
        mut txdata: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Vec<u8>), fidl::Error> {
        let _response = self
            .client
            .send_query::<DeviceExchangeVectorRequest, DeviceExchangeVectorResponse, DeviceMarker>(
                (txdata,),
                0x7facbdec2c3c03bd,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok((_response.status, _response.rxdata))
    }

    /// Returns true if the device can call |AssertCs()| and |DeassertCs()|.
    pub fn r#can_assert_cs(&self, ___deadline: zx::MonotonicInstant) -> Result<bool, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, DeviceCanAssertCsResponse, DeviceMarker>(
                (),
                0x1f8c12c089a9a874,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.can)
    }

    /// Assert CS for this device.
    /// Returns ZX_ERR_NOT_SUPPORTED if there is more than one device on the bus.
    pub fn r#assert_cs(&self, ___deadline: zx::MonotonicInstant) -> Result<i32, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, DeviceAssertCsResponse, DeviceMarker>(
                (),
                0x4ff66add7bd91ce6,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Deassert CS for this device.
    /// Returns ZX_ERR_BAD_STATE if CS is already deasserted.
    /// Returns ZX_ERR_NOT_SUPPORTED if there is more than one device on the bus.
    pub fn r#deassert_cs(&self, ___deadline: zx::MonotonicInstant) -> Result<i32, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, DeviceDeassertCsResponse, DeviceMarker>(
                (),
                0x5e4cd660a0bc0db8,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }
}

#[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.spi/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() }
    }

    /// Sends the data in buffer to the device.
    pub fn r#transmit(
        &self,
        mut buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_hardware_sharedmemory::SharedVmoIoTransmitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#transmit(self, buffer)
    }

    /// Receives data from the device into buffer.
    pub fn r#receive(
        &self,
        mut buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_hardware_sharedmemory::SharedVmoIoReceiveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#receive(self, buffer)
    }

    /// Simultaneously transmits and receives data. The size fields of tx_buffer and rx_buffer must
    /// be the same.
    pub fn r#exchange(
        &self,
        mut tx_buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
        mut rx_buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_hardware_sharedmemory::SharedVmoIoExchangeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#exchange(self, tx_buffer, rx_buffer)
    }

    /// Registers a VMO and transfers ownership to the driver.
    /// vmo_id: The ID chosen by the client that will be used in operations on this VMO.
    /// vmo: The handle, offset, and size of this VMO. IO operations on this VMO will be relative to
    /// the offset and size specified here.
    /// rights: A bit field of SharedVmoRight values indicating how this VMO may be used. Callers
    /// should assume that the driver will map and/or pin the VMO using these rights.
    pub fn r#register_vmo(
        &self,
        mut vmo_id: u32,
        mut vmo: fidl_fuchsia_mem::Range,
        mut rights: fidl_fuchsia_hardware_sharedmemory::SharedVmoRight,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterRegisterVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#register_vmo(self, vmo_id, vmo, rights)
    }

    /// Unmaps and/or unpins the VMO and returns the handle to the caller.
    pub fn r#unregister_vmo(
        &self,
        mut vmo_id: u32,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterUnregisterVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#unregister_vmo(self, vmo_id)
    }

    /// Half-duplex transmit data to a SPI device; always transmits the entire buffer on success.
    pub fn r#transmit_vector(
        &self,
        mut data: &[u8],
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DeviceProxyInterface::r#transmit_vector(self, data)
    }

    /// Half-duplex receive data from a SPI device; always reads the full size requested.
    pub fn r#receive_vector(
        &self,
        mut size: u32,
    ) -> fidl::client::QueryResponseFut<(i32, Vec<u8>), fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        DeviceProxyInterface::r#receive_vector(self, size)
    }

    /// Full-duplex SPI transaction. Received data will exactly equal the length of the transmit
    /// buffer.
    pub fn r#exchange_vector(
        &self,
        mut txdata: &[u8],
    ) -> fidl::client::QueryResponseFut<(i32, Vec<u8>), fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        DeviceProxyInterface::r#exchange_vector(self, txdata)
    }

    /// Returns true if the device can call |AssertCs()| and |DeassertCs()|.
    pub fn r#can_assert_cs(
        &self,
    ) -> fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DeviceProxyInterface::r#can_assert_cs(self)
    }

    /// Assert CS for this device.
    /// Returns ZX_ERR_NOT_SUPPORTED if there is more than one device on the bus.
    pub fn r#assert_cs(
        &self,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DeviceProxyInterface::r#assert_cs(self)
    }

    /// Deassert CS for this device.
    /// Returns ZX_ERR_BAD_STATE if CS is already deasserted.
    /// Returns ZX_ERR_NOT_SUPPORTED if there is more than one device on the bus.
    pub fn r#deassert_cs(
        &self,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DeviceProxyInterface::r#deassert_cs(self)
    }
}

impl DeviceProxyInterface for DeviceProxy {
    type TransmitResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_hardware_sharedmemory::SharedVmoIoTransmitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#transmit(
        &self,
        mut buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
    ) -> Self::TransmitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_hardware_sharedmemory::SharedVmoIoTransmitResult, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x791970e4c961b0bf,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl_fuchsia_hardware_sharedmemory::SharedVmoIoTransmitRequest,
            fidl_fuchsia_hardware_sharedmemory::SharedVmoIoTransmitResult,
        >(
            (buffer,),
            0x791970e4c961b0bf,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReceiveResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_hardware_sharedmemory::SharedVmoIoReceiveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#receive(
        &self,
        mut buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
    ) -> Self::ReceiveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_hardware_sharedmemory::SharedVmoIoReceiveResult, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1c31986cc443db59,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl_fuchsia_hardware_sharedmemory::SharedVmoIoReceiveRequest,
            fidl_fuchsia_hardware_sharedmemory::SharedVmoIoReceiveResult,
        >(
            (buffer,),
            0x1c31986cc443db59,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ExchangeResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_hardware_sharedmemory::SharedVmoIoExchangeResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#exchange(
        &self,
        mut tx_buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
        mut rx_buffer: &fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
    ) -> Self::ExchangeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_hardware_sharedmemory::SharedVmoIoExchangeResult, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ddad3b45d5deccc,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl_fuchsia_hardware_sharedmemory::SharedVmoIoExchangeRequest,
            fidl_fuchsia_hardware_sharedmemory::SharedVmoIoExchangeResult,
        >(
            (tx_buffer, rx_buffer,),
            0x6ddad3b45d5deccc,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RegisterVmoResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterRegisterVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#register_vmo(
        &self,
        mut vmo_id: u32,
        mut vmo: fidl_fuchsia_mem::Range,
        mut rights: fidl_fuchsia_hardware_sharedmemory::SharedVmoRight,
    ) -> Self::RegisterVmoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<
            fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterRegisterVmoResult,
            fidl::Error,
        > {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x31df51e1e6ea4a15,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterRegisterVmoRequest,
            fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterRegisterVmoResult,
        >(
            (vmo_id, &mut vmo, rights,),
            0x31df51e1e6ea4a15,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UnregisterVmoResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterUnregisterVmoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#unregister_vmo(&self, mut vmo_id: u32) -> Self::UnregisterVmoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<
            fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterUnregisterVmoResult,
            fidl::Error,
        > {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterUnregisterVmoResponse,
                    i32,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1194e9b693827109,
            >(_buf?)?;
            Ok(_response.map(|x| x.vmo))
        }
        self.client.send_query_and_decode::<
            fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterUnregisterVmoRequest,
            fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterUnregisterVmoResult,
        >(
            (vmo_id,),
            0x1194e9b693827109,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type TransmitVectorResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#transmit_vector(&self, mut data: &[u8]) -> Self::TransmitVectorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceTransmitVectorResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x46a82725fcb5e5d2,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<DeviceTransmitVectorRequest, i32>(
            (data,),
            0x46a82725fcb5e5d2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReceiveVectorResponseFut = fidl::client::QueryResponseFut<
        (i32, Vec<u8>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#receive_vector(&self, mut size: u32) -> Self::ReceiveVectorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Vec<u8>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceReceiveVectorResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x37b160ed6bdd3fd6,
            >(_buf?)?;
            Ok((_response.status, _response.data))
        }
        self.client.send_query_and_decode::<DeviceReceiveVectorRequest, (i32, Vec<u8>)>(
            (size,),
            0x37b160ed6bdd3fd6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ExchangeVectorResponseFut = fidl::client::QueryResponseFut<
        (i32, Vec<u8>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#exchange_vector(&self, mut txdata: &[u8]) -> Self::ExchangeVectorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Vec<u8>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceExchangeVectorResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7facbdec2c3c03bd,
            >(_buf?)?;
            Ok((_response.status, _response.rxdata))
        }
        self.client.send_query_and_decode::<DeviceExchangeVectorRequest, (i32, Vec<u8>)>(
            (txdata,),
            0x7facbdec2c3c03bd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CanAssertCsResponseFut =
        fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#can_assert_cs(&self) -> Self::CanAssertCsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<bool, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceCanAssertCsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1f8c12c089a9a874,
            >(_buf?)?;
            Ok(_response.can)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, bool>(
            (),
            0x1f8c12c089a9a874,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AssertCsResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#assert_cs(&self) -> Self::AssertCsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceAssertCsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4ff66add7bd91ce6,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
            (),
            0x4ff66add7bd91ce6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DeassertCsResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#deassert_cs(&self) -> Self::DeassertCsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceDeassertCsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5e4cd660a0bc0db8,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
            (),
            0x5e4cd660a0bc0db8,
            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 {}

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 {
            _ => 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.spi/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 {
                    0x791970e4c961b0bf => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl_fuchsia_hardware_sharedmemory::SharedVmoIoTransmitRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_hardware_sharedmemory::SharedVmoIoTransmitRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::Transmit {
                            buffer: req.buffer,

                            responder: DeviceTransmitResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1c31986cc443db59 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl_fuchsia_hardware_sharedmemory::SharedVmoIoReceiveRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_hardware_sharedmemory::SharedVmoIoReceiveRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::Receive {
                            buffer: req.buffer,

                            responder: DeviceReceiveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6ddad3b45d5deccc => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl_fuchsia_hardware_sharedmemory::SharedVmoIoExchangeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_hardware_sharedmemory::SharedVmoIoExchangeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::Exchange {
                            tx_buffer: req.tx_buffer,
                            rx_buffer: req.rx_buffer,

                            responder: DeviceExchangeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x31df51e1e6ea4a15 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterRegisterVmoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterRegisterVmoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::RegisterVmo {
                            vmo_id: req.vmo_id,
                            vmo: req.vmo,
                            rights: req.rights,

                            responder: DeviceRegisterVmoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1194e9b693827109 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterUnregisterVmoRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterUnregisterVmoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::UnregisterVmo {
                            vmo_id: req.vmo_id,

                            responder: DeviceUnregisterVmoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x46a82725fcb5e5d2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceTransmitVectorRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceTransmitVectorRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::TransmitVector {
                            data: req.data,

                            responder: DeviceTransmitVectorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x37b160ed6bdd3fd6 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceReceiveVectorRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceReceiveVectorRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::ReceiveVector {
                            size: req.size,

                            responder: DeviceReceiveVectorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7facbdec2c3c03bd => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceExchangeVectorRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceExchangeVectorRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::ExchangeVector {
                            txdata: req.txdata,

                            responder: DeviceExchangeVectorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1f8c12c089a9a874 => {
                        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::CanAssertCs {
                            responder: DeviceCanAssertCsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4ff66add7bd91ce6 => {
                        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::AssertCs {
                            responder: DeviceAssertCsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5e4cd660a0bc0db8 => {
                        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::DeassertCs {
                            responder: DeviceDeassertCsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum DeviceRequest {
    /// Sends the data in buffer to the device.
    Transmit {
        buffer: fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
        responder: DeviceTransmitResponder,
    },
    /// Receives data from the device into buffer.
    Receive {
        buffer: fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
        responder: DeviceReceiveResponder,
    },
    /// Simultaneously transmits and receives data. The size fields of tx_buffer and rx_buffer must
    /// be the same.
    Exchange {
        tx_buffer: fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
        rx_buffer: fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
        responder: DeviceExchangeResponder,
    },
    /// Registers a VMO and transfers ownership to the driver.
    /// vmo_id: The ID chosen by the client that will be used in operations on this VMO.
    /// vmo: The handle, offset, and size of this VMO. IO operations on this VMO will be relative to
    /// the offset and size specified here.
    /// rights: A bit field of SharedVmoRight values indicating how this VMO may be used. Callers
    /// should assume that the driver will map and/or pin the VMO using these rights.
    RegisterVmo {
        vmo_id: u32,
        vmo: fidl_fuchsia_mem::Range,
        rights: fidl_fuchsia_hardware_sharedmemory::SharedVmoRight,
        responder: DeviceRegisterVmoResponder,
    },
    /// Unmaps and/or unpins the VMO and returns the handle to the caller.
    UnregisterVmo { vmo_id: u32, responder: DeviceUnregisterVmoResponder },
    /// Half-duplex transmit data to a SPI device; always transmits the entire buffer on success.
    TransmitVector { data: Vec<u8>, responder: DeviceTransmitVectorResponder },
    /// Half-duplex receive data from a SPI device; always reads the full size requested.
    ReceiveVector { size: u32, responder: DeviceReceiveVectorResponder },
    /// Full-duplex SPI transaction. Received data will exactly equal the length of the transmit
    /// buffer.
    ExchangeVector { txdata: Vec<u8>, responder: DeviceExchangeVectorResponder },
    /// Returns true if the device can call |AssertCs()| and |DeassertCs()|.
    CanAssertCs { responder: DeviceCanAssertCsResponder },
    /// Assert CS for this device.
    /// Returns ZX_ERR_NOT_SUPPORTED if there is more than one device on the bus.
    AssertCs { responder: DeviceAssertCsResponder },
    /// Deassert CS for this device.
    /// Returns ZX_ERR_BAD_STATE if CS is already deasserted.
    /// Returns ZX_ERR_NOT_SUPPORTED if there is more than one device on the bus.
    DeassertCs { responder: DeviceDeassertCsResponder },
}

impl DeviceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_transmit(
        self,
    ) -> Option<(fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer, DeviceTransmitResponder)>
    {
        if let DeviceRequest::Transmit { buffer, responder } = self {
            Some((buffer, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_receive(
        self,
    ) -> Option<(fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer, DeviceReceiveResponder)> {
        if let DeviceRequest::Receive { buffer, responder } = self {
            Some((buffer, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_exchange(
        self,
    ) -> Option<(
        fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
        fidl_fuchsia_hardware_sharedmemory::SharedVmoBuffer,
        DeviceExchangeResponder,
    )> {
        if let DeviceRequest::Exchange { tx_buffer, rx_buffer, responder } = self {
            Some((tx_buffer, rx_buffer, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_register_vmo(
        self,
    ) -> Option<(
        u32,
        fidl_fuchsia_mem::Range,
        fidl_fuchsia_hardware_sharedmemory::SharedVmoRight,
        DeviceRegisterVmoResponder,
    )> {
        if let DeviceRequest::RegisterVmo { vmo_id, vmo, rights, responder } = self {
            Some((vmo_id, vmo, rights, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_unregister_vmo(self) -> Option<(u32, DeviceUnregisterVmoResponder)> {
        if let DeviceRequest::UnregisterVmo { vmo_id, responder } = self {
            Some((vmo_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_transmit_vector(self) -> Option<(Vec<u8>, DeviceTransmitVectorResponder)> {
        if let DeviceRequest::TransmitVector { data, responder } = self {
            Some((data, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_receive_vector(self) -> Option<(u32, DeviceReceiveVectorResponder)> {
        if let DeviceRequest::ReceiveVector { size, responder } = self {
            Some((size, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_exchange_vector(self) -> Option<(Vec<u8>, DeviceExchangeVectorResponder)> {
        if let DeviceRequest::ExchangeVector { txdata, responder } = self {
            Some((txdata, responder))
        } else {
            None
        }
    }

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

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

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

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DeviceRequest::Transmit { .. } => "transmit",
            DeviceRequest::Receive { .. } => "receive",
            DeviceRequest::Exchange { .. } => "exchange",
            DeviceRequest::RegisterVmo { .. } => "register_vmo",
            DeviceRequest::UnregisterVmo { .. } => "unregister_vmo",
            DeviceRequest::TransmitVector { .. } => "transmit_vector",
            DeviceRequest::ReceiveVector { .. } => "receive_vector",
            DeviceRequest::ExchangeVector { .. } => "exchange_vector",
            DeviceRequest::CanAssertCs { .. } => "can_assert_cs",
            DeviceRequest::AssertCs { .. } => "assert_cs",
            DeviceRequest::DeassertCs { .. } => "deassert_cs",
        }
    }
}

#[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 DeviceTransmitResponder {
    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 DeviceTransmitResponder {
    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 DeviceTransmitResponder {
    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 DeviceTransmitResponder {
    /// 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,
                0x791970e4c961b0bf,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceReceiveResponder {
    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 DeviceReceiveResponder {
    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 DeviceReceiveResponder {
    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 DeviceReceiveResponder {
    /// 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,
                0x1c31986cc443db59,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceExchangeResponder {
    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 DeviceExchangeResponder {
    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 DeviceExchangeResponder {
    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 DeviceExchangeResponder {
    /// 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,
                0x6ddad3b45d5deccc,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceRegisterVmoResponder {
    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 DeviceRegisterVmoResponder {
    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 DeviceRegisterVmoResponder {
    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 DeviceRegisterVmoResponder {
    /// 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,
                0x31df51e1e6ea4a15,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceUnregisterVmoResponder {
    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 DeviceUnregisterVmoResponder {
    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 DeviceUnregisterVmoResponder {
    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 DeviceUnregisterVmoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<fidl::Vmo, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

    fn send_raw(&self, mut result: Result<fidl::Vmo, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl_fuchsia_hardware_sharedmemory::SharedVmoRegisterUnregisterVmoResponse,
            i32,
        >>(
            result.map(|vmo| (vmo,)),
            self.tx_id,
            0x1194e9b693827109,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceTransmitVectorResponder {
    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 DeviceTransmitVectorResponder {
    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 DeviceTransmitVectorResponder {
    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 DeviceTransmitVectorResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut status: i32) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceReceiveVectorResponder {
    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 DeviceReceiveVectorResponder {
    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 DeviceReceiveVectorResponder {
    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 DeviceReceiveVectorResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut status: i32, mut data: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status, data);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

    fn send_raw(&self, mut status: i32, mut data: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceReceiveVectorResponse>(
            (status, data),
            self.tx_id,
            0x37b160ed6bdd3fd6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceExchangeVectorResponder {
    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 DeviceExchangeVectorResponder {
    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 DeviceExchangeVectorResponder {
    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 DeviceExchangeVectorResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut status: i32, mut rxdata: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status, rxdata);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

    fn send_raw(&self, mut status: i32, mut rxdata: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceExchangeVectorResponse>(
            (status, rxdata),
            self.tx_id,
            0x7facbdec2c3c03bd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceCanAssertCsResponder {
    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 DeviceCanAssertCsResponder {
    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 DeviceCanAssertCsResponder {
    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 DeviceCanAssertCsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut can: bool) -> Result<(), fidl::Error> {
        let _result = self.send_raw(can);
        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 can: bool) -> Result<(), fidl::Error> {
        let _result = self.send_raw(can);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut can: bool) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceCanAssertCsResponse>(
            (can,),
            self.tx_id,
            0x1f8c12c089a9a874,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceAssertCsResponder {
    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 DeviceAssertCsResponder {
    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 DeviceAssertCsResponder {
    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 DeviceAssertCsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut status: i32) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceDeassertCsResponder {
    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 DeviceDeassertCsResponder {
    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 DeviceDeassertCsResponder {
    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 DeviceDeassertCsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut status: i32) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

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

impl fidl::endpoints::ProtocolMarker for TestMarker {
    type Proxy = TestProxy;
    type RequestStream = TestRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = TestSynchronousProxy;

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

pub trait TestProxyInterface: Send + Sync {
    type GetResponseFut: std::future::Future<
            Output = Result<fidl_fuchsia_driver_token::NodeTokenGetResult, fidl::Error>,
        > + Send;
    fn r#get(&self) -> Self::GetResponseFut;
    type ConnectSpiLoopbackResponseFut: std::future::Future<Output = Result<TestConnectSpiLoopbackResult, fidl::Error>>
        + Send;
    fn r#connect_spi_loopback(
        &self,
        server: fidl::endpoints::ServerEnd<DeviceMarker>,
    ) -> Self::ConnectSpiLoopbackResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct TestSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for TestSynchronousProxy {
    type Proxy = TestProxy;
    type Protocol = TestMarker;

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

    pub fn r#get(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_driver_token::NodeTokenGetResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                fidl_fuchsia_driver_token::NodeTokenGetResponse,
                i32,
            >, TestMarker>(
                (),
                0x64166e3a6984b1d9,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.token))
    }

    /// Opens a connection to a SPI device in loopback mode, to be used for testing.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if debugging is not enabled in this build.
    ///
    /// If the SPI implementation driver itself does not support loopback mode, this call will
    /// succeed, but calls to the Device will fail with ZX_ERR_NOT_SUPPORTED instead.
    pub fn r#connect_spi_loopback(
        &self,
        mut server: fidl::endpoints::ServerEnd<DeviceMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<TestConnectSpiLoopbackResult, fidl::Error> {
        let _response = self.client.send_query::<
            TestConnectSpiLoopbackRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            TestMarker,
        >(
            (server,),
            0x420403db2950bb2a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for TestProxy {
    type Protocol = TestMarker;

    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 TestProxy {
    /// Create a new Proxy for fuchsia.hardware.spi/Test.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <TestMarker 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) -> TestEventStream {
        TestEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#get(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_driver_token::NodeTokenGetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TestProxyInterface::r#get(self)
    }

    /// Opens a connection to a SPI device in loopback mode, to be used for testing.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if debugging is not enabled in this build.
    ///
    /// If the SPI implementation driver itself does not support loopback mode, this call will
    /// succeed, but calls to the Device will fail with ZX_ERR_NOT_SUPPORTED instead.
    pub fn r#connect_spi_loopback(
        &self,
        mut server: fidl::endpoints::ServerEnd<DeviceMarker>,
    ) -> fidl::client::QueryResponseFut<
        TestConnectSpiLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TestProxyInterface::r#connect_spi_loopback(self, server)
    }
}

impl TestProxyInterface for TestProxy {
    type GetResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_driver_token::NodeTokenGetResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get(&self) -> Self::GetResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_driver_token::NodeTokenGetResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl_fuchsia_driver_token::NodeTokenGetResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x64166e3a6984b1d9,
            >(_buf?)?;
            Ok(_response.map(|x| x.token))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_driver_token::NodeTokenGetResult,
        >(
            (),
            0x64166e3a6984b1d9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ConnectSpiLoopbackResponseFut = fidl::client::QueryResponseFut<
        TestConnectSpiLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect_spi_loopback(
        &self,
        mut server: fidl::endpoints::ServerEnd<DeviceMarker>,
    ) -> Self::ConnectSpiLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<TestConnectSpiLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x420403db2950bb2a,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<TestConnectSpiLoopbackRequest, TestConnectSpiLoopbackResult>(
                (server,),
                0x420403db2950bb2a,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for TestRequestStream {
    type Protocol = TestMarker;
    type ControlHandle = TestControlHandle;

    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 {
        TestControlHandle { 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 TestRequestStream {
    type Item = Result<TestRequest, 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 TestRequestStream 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 {
                    0x64166e3a6984b1d9 => {
                        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 = TestControlHandle { inner: this.inner.clone() };
                        Ok(TestRequest::Get {
                            responder: TestGetResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x420403db2950bb2a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            TestConnectSpiLoopbackRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TestConnectSpiLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = TestControlHandle { inner: this.inner.clone() };
                        Ok(TestRequest::ConnectSpiLoopback {
                            server: req.server,

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

#[derive(Debug)]
pub enum TestRequest {
    Get {
        responder: TestGetResponder,
    },
    /// Opens a connection to a SPI device in loopback mode, to be used for testing.
    ///
    /// Returns ZX_ERR_NOT_SUPPORTED if debugging is not enabled in this build.
    ///
    /// If the SPI implementation driver itself does not support loopback mode, this call will
    /// succeed, but calls to the Device will fail with ZX_ERR_NOT_SUPPORTED instead.
    ConnectSpiLoopback {
        server: fidl::endpoints::ServerEnd<DeviceMarker>,
        responder: TestConnectSpiLoopbackResponder,
    },
    /// 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: TestControlHandle,
        method_type: fidl::MethodType,
    },
}

impl TestRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get(self) -> Option<(TestGetResponder)> {
        if let TestRequest::Get { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect_spi_loopback(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<DeviceMarker>, TestConnectSpiLoopbackResponder)> {
        if let TestRequest::ConnectSpiLoopback { server, responder } = self {
            Some((server, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<fidl::Event, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl_fuchsia_driver_token::NodeTokenGetResponse,
            i32,
        >>(
            result.map(|token| (token,)),
            self.tx_id,
            0x64166e3a6984b1d9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for ControllerServiceMarker {
    type Proxy = ControllerServiceProxy;
    type Request = ControllerServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.spi.ControllerService";
}

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

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

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

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

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

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

#[cfg(target_os = "fuchsia")]
impl ControllerServiceProxy {
    pub fn connect_to_device(&self) -> Result<ControllerProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<ControllerMarker>();
        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<ControllerSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<ControllerMarker>();
        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<ControllerMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("device", server_end.into_channel())
    }

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

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

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

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

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

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

    fn member_names() -> &'static [&'static str] {
        &["device"]
    }
}
#[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_device(&self) -> Result<DeviceProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<DeviceMarker>();
        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<DeviceSynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<DeviceMarker>();
        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<DeviceMarker>,
    ) -> Result<(), fidl::Error> {
        self.0.open_member("device", server_end.into_channel())
    }

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for TestServiceMarker {
    type Proxy = TestServiceProxy;
    type Request = TestServiceRequest;
    const SERVICE_NAME: &'static str = "fuchsia.hardware.spi.TestService";
}

/// A request for one of the member protocols of TestService.
///
#[cfg(target_os = "fuchsia")]
pub enum TestServiceRequest {
    Test(TestRequestStream),
}

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

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

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

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

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

#[cfg(target_os = "fuchsia")]
impl TestServiceProxy {
    pub fn connect_to_test(&self) -> Result<TestProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<TestMarker>();
        self.connect_channel_to_test(server_end)?;
        Ok(proxy)
    }

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

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

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

mod internal {
    use super::*;

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

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

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

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