fidl_fuchsia_driver_lab/

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

#[derive(Debug, PartialEq)]
pub struct ProxyOpenSessionRequest {
    pub context: RunContext,
    pub mode: SessionMode,
    pub expectations: Expectations,
    pub allowlist: Vec<AccessRule>,
    pub session: fidl::endpoints::ServerEnd<SessionMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SessionOpenGpioRequest {
    pub resource: u32,
    pub endpoint: fidl::endpoints::ServerEnd<GpioEndpointMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SessionOpenI2cRequest {
    pub resource: u32,
    pub endpoint: fidl::endpoints::ServerEnd<I2cEndpointMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SessionOpenSpiRequest {
    pub resource: u32,
    pub endpoint: fidl::endpoints::ServerEnd<SpiEndpointMarker>,
}

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

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

impl fidl::endpoints::ProtocolMarker for GpioEndpointMarker {
    type Proxy = GpioEndpointProxy;
    type RequestStream = GpioEndpointRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = GpioEndpointSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) GpioEndpoint";
}
pub type GpioEndpointReadResult = Result<(bool, u64, i64), OperationError>;
pub type GpioEndpointWriteResult = Result<(u64, i64), OperationError>;

pub trait GpioEndpointProxyInterface: Send + Sync {
    type ReadResponseFut: std::future::Future<Output = Result<GpioEndpointReadResult, fidl::Error>>
        + Send;
    fn r#read(&self) -> Self::ReadResponseFut;
    type WriteResponseFut: std::future::Future<Output = Result<GpioEndpointWriteResult, fidl::Error>>
        + Send;
    fn r#write(&self, value: bool) -> Self::WriteResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct GpioEndpointSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for GpioEndpointSynchronousProxy {
    type Proxy = GpioEndpointProxy;
    type Protocol = GpioEndpointMarker;

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

    pub fn r#read(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GpioEndpointReadResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<GpioReadResult, OperationError>,
            GpioEndpointMarker,
        >(
            (),
            0xb7efebe5882f6f1,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<GpioEndpointMarker>("read")?;
        Ok(_response.map(|x| (x.value, x.audit_seq, x.timestamp_ns)))
    }

    pub fn r#write(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<GpioEndpointWriteResult, fidl::Error> {
        let _response = self.client.send_query::<
            GpioEndpointWriteRequest,
            fidl::encoding::FlexibleResultType<GpioWriteResult, OperationError>,
            GpioEndpointMarker,
        >(
            (value,),
            0x3d1822432f45c309,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<GpioEndpointMarker>("write")?;
        Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for GpioEndpointProxy {
    type Protocol = GpioEndpointMarker;

    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 GpioEndpointProxy {
    /// Create a new Proxy for fuchsia.driver.lab/GpioEndpoint.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <GpioEndpointMarker 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) -> GpioEndpointEventStream {
        GpioEndpointEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#read(
        &self,
    ) -> fidl::client::QueryResponseFut<
        GpioEndpointReadResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        GpioEndpointProxyInterface::r#read(self)
    }

    pub fn r#write(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        GpioEndpointWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        GpioEndpointProxyInterface::r#write(self, value)
    }
}

impl GpioEndpointProxyInterface for GpioEndpointProxy {
    type ReadResponseFut = fidl::client::QueryResponseFut<
        GpioEndpointReadResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read(&self) -> Self::ReadResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GpioEndpointReadResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<GpioReadResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xb7efebe5882f6f1,
            >(_buf?)?
            .into_result::<GpioEndpointMarker>("read")?;
            Ok(_response.map(|x| (x.value, x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, GpioEndpointReadResult>(
            (),
            0xb7efebe5882f6f1,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type WriteResponseFut = fidl::client::QueryResponseFut<
        GpioEndpointWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write(&self, mut value: bool) -> Self::WriteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<GpioEndpointWriteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<GpioWriteResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3d1822432f45c309,
            >(_buf?)?
            .into_result::<GpioEndpointMarker>("write")?;
            Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<GpioEndpointWriteRequest, GpioEndpointWriteResult>(
            (value,),
            0x3d1822432f45c309,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.driver.lab/GpioEndpoint.
pub struct GpioEndpointRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for GpioEndpointRequestStream {
    type Protocol = GpioEndpointMarker;
    type ControlHandle = GpioEndpointControlHandle;

    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 {
        GpioEndpointControlHandle { 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 GpioEndpointRequestStream {
    type Item = Result<GpioEndpointRequest, 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 GpioEndpointRequestStream 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 {
                    0xb7efebe5882f6f1 => {
                        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 =
                            GpioEndpointControlHandle { inner: this.inner.clone() };
                        Ok(GpioEndpointRequest::Read {
                            responder: GpioEndpointReadResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3d1822432f45c309 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            GpioEndpointWriteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GpioEndpointWriteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            GpioEndpointControlHandle { inner: this.inner.clone() };
                        Ok(GpioEndpointRequest::Write {
                            value: req.value,

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

/// Typed endpoint for a GPIO protocol resource.
#[derive(Debug)]
pub enum GpioEndpointRequest {
    Read {
        responder: GpioEndpointReadResponder,
    },
    Write {
        value: bool,
        responder: GpioEndpointWriteResponder,
    },
    /// 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: GpioEndpointControlHandle,
        method_type: fidl::MethodType,
    },
}

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_write(self) -> Option<(bool, GpioEndpointWriteResponder)> {
        if let GpioEndpointRequest::Write { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<(bool, u64, i64), OperationError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleResultType<GpioReadResult, OperationError>>(
                fidl::encoding::FlexibleResult::new(result),
                self.tx_id,
                0xb7efebe5882f6f1,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for I2cEndpointMarker {
    type Proxy = I2cEndpointProxy;
    type RequestStream = I2cEndpointRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = I2cEndpointSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) I2cEndpoint";
}
pub type I2cEndpointTransferResult = Result<(Vec<u8>, u64, i64), OperationError>;

pub trait I2cEndpointProxyInterface: Send + Sync {
    type TransferResponseFut: std::future::Future<Output = Result<I2cEndpointTransferResult, fidl::Error>>
        + Send;
    fn r#transfer(&self, write_data: &[u8], read_length: u32) -> Self::TransferResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct I2cEndpointSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for I2cEndpointSynchronousProxy {
    type Proxy = I2cEndpointProxy;
    type Protocol = I2cEndpointMarker;

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

    pub fn r#transfer(
        &self,
        mut write_data: &[u8],
        mut read_length: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<I2cEndpointTransferResult, fidl::Error> {
        let _response = self.client.send_query::<
            I2cEndpointTransferRequest,
            fidl::encoding::FlexibleResultType<I2cTransferResult, OperationError>,
            I2cEndpointMarker,
        >(
            (write_data, read_length,),
            0xbb27bd944e8143,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<I2cEndpointMarker>("transfer")?;
        Ok(_response.map(|x| (x.read_data, x.audit_seq, x.timestamp_ns)))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for I2cEndpointProxy {
    type Protocol = I2cEndpointMarker;

    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 I2cEndpointProxy {
    /// Create a new Proxy for fuchsia.driver.lab/I2cEndpoint.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <I2cEndpointMarker 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) -> I2cEndpointEventStream {
        I2cEndpointEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#transfer(
        &self,
        mut write_data: &[u8],
        mut read_length: u32,
    ) -> fidl::client::QueryResponseFut<
        I2cEndpointTransferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        I2cEndpointProxyInterface::r#transfer(self, write_data, read_length)
    }
}

impl I2cEndpointProxyInterface for I2cEndpointProxy {
    type TransferResponseFut = fidl::client::QueryResponseFut<
        I2cEndpointTransferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#transfer(&self, mut write_data: &[u8], mut read_length: u32) -> Self::TransferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<I2cEndpointTransferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<I2cTransferResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xbb27bd944e8143,
            >(_buf?)?
            .into_result::<I2cEndpointMarker>("transfer")?;
            Ok(_response.map(|x| (x.read_data, x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<I2cEndpointTransferRequest, I2cEndpointTransferResult>(
            (write_data, read_length),
            0xbb27bd944e8143,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.driver.lab/I2cEndpoint.
pub struct I2cEndpointRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for I2cEndpointRequestStream {
    type Protocol = I2cEndpointMarker;
    type ControlHandle = I2cEndpointControlHandle;

    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 {
        I2cEndpointControlHandle { 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 I2cEndpointRequestStream {
    type Item = Result<I2cEndpointRequest, 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 I2cEndpointRequestStream 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 {
                    0xbb27bd944e8143 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            I2cEndpointTransferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<I2cEndpointTransferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = I2cEndpointControlHandle { inner: this.inner.clone() };
                        Ok(I2cEndpointRequest::Transfer {
                            write_data: req.write_data,
                            read_length: req.read_length,

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

/// Typed endpoint for an I2C protocol resource.
#[derive(Debug)]
pub enum I2cEndpointRequest {
    Transfer {
        write_data: Vec<u8>,
        read_length: u32,
        responder: I2cEndpointTransferResponder,
    },
    /// 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: I2cEndpointControlHandle,
        method_type: fidl::MethodType,
    },
}

impl I2cEndpointRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_transfer(self) -> Option<(Vec<u8>, u32, I2cEndpointTransferResponder)> {
        if let I2cEndpointRequest::Transfer { write_data, read_length, responder } = self {
            Some((write_data, read_length, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for Proxy_Marker {
    type Proxy = Proxy_Proxy;
    type RequestStream = Proxy_RequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = Proxy_SynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.driver.lab.Proxy";
}
impl fidl::endpoints::DiscoverableProtocolMarker for Proxy_Marker {}
pub type ProxyOpenSessionResult = Result<u64, OpenSessionError>;

pub trait Proxy_ProxyInterface: Send + Sync {
    type DescribeResponseFut: std::future::Future<Output = Result<ProxyDescription, fidl::Error>>
        + Send;
    fn r#describe(&self) -> Self::DescribeResponseFut;
    type OpenSessionResponseFut: std::future::Future<Output = Result<ProxyOpenSessionResult, fidl::Error>>
        + Send;
    fn r#open_session(
        &self,
        context: &RunContext,
        mode: SessionMode,
        expectations: &Expectations,
        allowlist: &[AccessRule],
        session: fidl::endpoints::ServerEnd<SessionMarker>,
    ) -> Self::OpenSessionResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct Proxy_SynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for Proxy_SynchronousProxy {
    type Proxy = Proxy_Proxy;
    type Protocol = Proxy_Marker;

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

    /// Identity, resources, limits, and digests of this proxy instance.
    pub fn r#describe(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProxyDescription, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<ProxyDescription>,
            Proxy_Marker,
        >(
            (),
            0x7a79d503792884fb,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<Proxy_Marker>("describe")?;
        Ok(_response)
    }

    /// Opens a session with an exact allowlist. Stale expectations and
    /// rejected allowlists create no session and touch no hardware.
    pub fn r#open_session(
        &self,
        mut context: &RunContext,
        mut mode: SessionMode,
        mut expectations: &Expectations,
        mut allowlist: &[AccessRule],
        mut session: fidl::endpoints::ServerEnd<SessionMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProxyOpenSessionResult, fidl::Error> {
        let _response = self.client.send_query::<
            ProxyOpenSessionRequest,
            fidl::encoding::FlexibleResultType<ProxyOpenSessionResponse, OpenSessionError>,
            Proxy_Marker,
        >(
            (context, mode, expectations, allowlist, session,),
            0x31decc49da4ed5f4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<Proxy_Marker>("open_session")?;
        Ok(_response.map(|x| x.session_id))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for Proxy_Proxy {
    type Protocol = Proxy_Marker;

    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 Proxy_Proxy {
    /// Create a new Proxy for fuchsia.driver.lab/Proxy.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <Proxy_Marker 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) -> Proxy_EventStream {
        Proxy_EventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Identity, resources, limits, and digests of this proxy instance.
    pub fn r#describe(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ProxyDescription,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        Proxy_ProxyInterface::r#describe(self)
    }

    /// Opens a session with an exact allowlist. Stale expectations and
    /// rejected allowlists create no session and touch no hardware.
    pub fn r#open_session(
        &self,
        mut context: &RunContext,
        mut mode: SessionMode,
        mut expectations: &Expectations,
        mut allowlist: &[AccessRule],
        mut session: fidl::endpoints::ServerEnd<SessionMarker>,
    ) -> fidl::client::QueryResponseFut<
        ProxyOpenSessionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        Proxy_ProxyInterface::r#open_session(self, context, mode, expectations, allowlist, session)
    }
}

impl Proxy_ProxyInterface for Proxy_Proxy {
    type DescribeResponseFut = fidl::client::QueryResponseFut<
        ProxyDescription,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#describe(&self) -> Self::DescribeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProxyDescription, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<ProxyDescription>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7a79d503792884fb,
            >(_buf?)?
            .into_result::<Proxy_Marker>("describe")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ProxyDescription>(
            (),
            0x7a79d503792884fb,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type OpenSessionResponseFut = fidl::client::QueryResponseFut<
        ProxyOpenSessionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_session(
        &self,
        mut context: &RunContext,
        mut mode: SessionMode,
        mut expectations: &Expectations,
        mut allowlist: &[AccessRule],
        mut session: fidl::endpoints::ServerEnd<SessionMarker>,
    ) -> Self::OpenSessionResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProxyOpenSessionResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ProxyOpenSessionResponse, OpenSessionError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x31decc49da4ed5f4,
            >(_buf?)?
            .into_result::<Proxy_Marker>("open_session")?;
            Ok(_response.map(|x| x.session_id))
        }
        self.client.send_query_and_decode::<ProxyOpenSessionRequest, ProxyOpenSessionResult>(
            (context, mode, expectations, allowlist, session),
            0x31decc49da4ed5f4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.driver.lab/Proxy.
pub struct Proxy_RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for Proxy_RequestStream {
    type Protocol = Proxy_Marker;
    type ControlHandle = Proxy_ControlHandle;

    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 {
        Proxy_ControlHandle { 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 Proxy_RequestStream {
    type Item = Result<Proxy_Request, 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 Proxy_RequestStream 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 {
                    0x7a79d503792884fb => {
                        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 = Proxy_ControlHandle { inner: this.inner.clone() };
                        Ok(Proxy_Request::Describe {
                            responder: Proxy_DescribeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x31decc49da4ed5f4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProxyOpenSessionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProxyOpenSessionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = Proxy_ControlHandle { inner: this.inner.clone() };
                        Ok(Proxy_Request::OpenSession {
                            context: req.context,
                            mode: req.mode,
                            expectations: req.expectations,
                            allowlist: req.allowlist,
                            session: req.session,

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

#[derive(Debug)]
pub enum Proxy_Request {
    /// Identity, resources, limits, and digests of this proxy instance.
    Describe { responder: Proxy_DescribeResponder },
    /// Opens a session with an exact allowlist. Stale expectations and
    /// rejected allowlists create no session and touch no hardware.
    OpenSession {
        context: RunContext,
        mode: SessionMode,
        expectations: Expectations,
        allowlist: Vec<AccessRule>,
        session: fidl::endpoints::ServerEnd<SessionMarker>,
        responder: Proxy_OpenSessionResponder,
    },
    /// 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: Proxy_ControlHandle,
        method_type: fidl::MethodType,
    },
}

impl Proxy_Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_describe(self) -> Option<(Proxy_DescribeResponder)> {
        if let Proxy_Request::Describe { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_session(
        self,
    ) -> Option<(
        RunContext,
        SessionMode,
        Expectations,
        Vec<AccessRule>,
        fidl::endpoints::ServerEnd<SessionMarker>,
        Proxy_OpenSessionResponder,
    )> {
        if let Proxy_Request::OpenSession {
            context,
            mode,
            expectations,
            allowlist,
            session,
            responder,
        } = self
        {
            Some((context, mode, expectations, allowlist, session, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<u64, OpenSessionError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            ProxyOpenSessionResponse,
            OpenSessionError,
        >>(
            fidl::encoding::FlexibleResult::new(result.map(|session_id| (session_id,))),
            self.tx_id,
            0x31decc49da4ed5f4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for SessionMarker {
    type Proxy = SessionProxy;
    type RequestStream = SessionRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SessionSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Session";
}
pub type SessionRead32Result = Result<(u32, u64, i64), OperationError>;
pub type SessionSnapshotResult = Result<(Vec<SnapshotItemResult>, bool), OperationError>;
pub type SessionWrite32Result = Result<(u32, u64, i64), OperationError>;
pub type SessionPoll32Result = Result<(u32, u64, i64), OperationError>;
pub type SessionExecuteSequenceResult = Result<(Vec<SequenceItemResult>, bool), OperationError>;
pub type SessionGpioReadResult = Result<(bool, u64, i64), OperationError>;
pub type SessionGpioWriteResult = Result<(u64, i64), OperationError>;
pub type SessionI2cTransferResult = Result<(Vec<u8>, u64, i64), OperationError>;
pub type SessionSpiTransmitResult = Result<(Vec<u8>, u64, i64), OperationError>;
pub type SessionOpenGpioResult = Result<(), OperationError>;
pub type SessionOpenI2cResult = Result<(), OperationError>;
pub type SessionOpenSpiResult = Result<(), OperationError>;
pub type SessionWaitForInterruptResult = Result<(u32, u64, u64, i64, u64), OperationError>;
pub type SessionClockEnableResult = Result<(u64, i64), OperationError>;
pub type SessionClockDisableResult = Result<(u64, i64), OperationError>;
pub type SessionClockIsEnabledResult = Result<(bool, u64, i64), OperationError>;
pub type SessionClockSetRateResult = Result<(u64, i64), OperationError>;
pub type SessionClockQueryRateResult = Result<(u64, u64, i64), OperationError>;
pub type SessionClockGetRateResult = Result<(u64, u64, i64), OperationError>;
pub type SessionResetAssertResult = Result<(u64, i64), OperationError>;
pub type SessionResetDeassertResult = Result<(u64, i64), OperationError>;
pub type SessionResetToggleResult = Result<(u64, i64), OperationError>;
pub type SessionResetStatusResult = Result<(bool, u64, i64), OperationError>;
pub type SessionSerialReadResult = Result<(Vec<u8>, u64, i64), OperationError>;
pub type SessionSerialWriteResult = Result<(u64, i64), OperationError>;

pub trait SessionProxyInterface: Send + Sync {
    type Read32ResponseFut: std::future::Future<Output = Result<SessionRead32Result, fidl::Error>>
        + Send;
    fn r#read32(&self, resource: u32, offset: u64) -> Self::Read32ResponseFut;
    type SnapshotResponseFut: std::future::Future<Output = Result<SessionSnapshotResult, fidl::Error>>
        + Send;
    fn r#snapshot(&self, items: &[SnapshotItem]) -> Self::SnapshotResponseFut;
    type ReadAuditResponseFut: std::future::Future<Output = Result<(Vec<AuditEntry>, bool, u64, u64), fidl::Error>>
        + Send;
    fn r#read_audit(&self, cursor: u64, limit: u32) -> Self::ReadAuditResponseFut;
    type Write32ResponseFut: std::future::Future<Output = Result<SessionWrite32Result, fidl::Error>>
        + Send;
    fn r#write32(
        &self,
        resource: u32,
        offset: u64,
        value: u32,
        write_mask: u32,
        precondition: Option<&WritePrecondition>,
        readback: bool,
    ) -> Self::Write32ResponseFut;
    type Poll32ResponseFut: std::future::Future<Output = Result<SessionPoll32Result, fidl::Error>>
        + Send;
    fn r#poll32(
        &self,
        resource: u32,
        offset: u64,
        expected: u32,
        mask: u32,
        interval_ns: i64,
        timeout_ns: i64,
    ) -> Self::Poll32ResponseFut;
    type ExecuteSequenceResponseFut: std::future::Future<Output = Result<SessionExecuteSequenceResult, fidl::Error>>
        + Send;
    fn r#execute_sequence(&self, items: &[SequenceItem]) -> Self::ExecuteSequenceResponseFut;
    type GpioReadResponseFut: std::future::Future<Output = Result<SessionGpioReadResult, fidl::Error>>
        + Send;
    fn r#gpio_read(&self, resource: u32) -> Self::GpioReadResponseFut;
    type GpioWriteResponseFut: std::future::Future<Output = Result<SessionGpioWriteResult, fidl::Error>>
        + Send;
    fn r#gpio_write(&self, resource: u32, value: bool) -> Self::GpioWriteResponseFut;
    type I2cTransferResponseFut: std::future::Future<Output = Result<SessionI2cTransferResult, fidl::Error>>
        + Send;
    fn r#i2c_transfer(
        &self,
        resource: u32,
        write_data: &[u8],
        read_length: u32,
    ) -> Self::I2cTransferResponseFut;
    type SpiTransmitResponseFut: std::future::Future<Output = Result<SessionSpiTransmitResult, fidl::Error>>
        + Send;
    fn r#spi_transmit(&self, resource: u32, tx_data: &[u8]) -> Self::SpiTransmitResponseFut;
    type OpenGpioResponseFut: std::future::Future<Output = Result<SessionOpenGpioResult, fidl::Error>>
        + Send;
    fn r#open_gpio(
        &self,
        resource: u32,
        endpoint: fidl::endpoints::ServerEnd<GpioEndpointMarker>,
    ) -> Self::OpenGpioResponseFut;
    type OpenI2cResponseFut: std::future::Future<Output = Result<SessionOpenI2cResult, fidl::Error>>
        + Send;
    fn r#open_i2c(
        &self,
        resource: u32,
        endpoint: fidl::endpoints::ServerEnd<I2cEndpointMarker>,
    ) -> Self::OpenI2cResponseFut;
    type OpenSpiResponseFut: std::future::Future<Output = Result<SessionOpenSpiResult, fidl::Error>>
        + Send;
    fn r#open_spi(
        &self,
        resource: u32,
        endpoint: fidl::endpoints::ServerEnd<SpiEndpointMarker>,
    ) -> Self::OpenSpiResponseFut;
    type WaitForInterruptResponseFut: std::future::Future<Output = Result<SessionWaitForInterruptResult, fidl::Error>>
        + Send;
    fn r#wait_for_interrupt(
        &self,
        resource: u32,
        after_sequence: u64,
        timeout_ns: i64,
    ) -> Self::WaitForInterruptResponseFut;
    type ClockEnableResponseFut: std::future::Future<Output = Result<SessionClockEnableResult, fidl::Error>>
        + Send;
    fn r#clock_enable(&self, resource: u32) -> Self::ClockEnableResponseFut;
    type ClockDisableResponseFut: std::future::Future<Output = Result<SessionClockDisableResult, fidl::Error>>
        + Send;
    fn r#clock_disable(&self, resource: u32) -> Self::ClockDisableResponseFut;
    type ClockIsEnabledResponseFut: std::future::Future<Output = Result<SessionClockIsEnabledResult, fidl::Error>>
        + Send;
    fn r#clock_is_enabled(&self, resource: u32) -> Self::ClockIsEnabledResponseFut;
    type ClockSetRateResponseFut: std::future::Future<Output = Result<SessionClockSetRateResult, fidl::Error>>
        + Send;
    fn r#clock_set_rate(&self, resource: u32, hz: u64) -> Self::ClockSetRateResponseFut;
    type ClockQueryRateResponseFut: std::future::Future<Output = Result<SessionClockQueryRateResult, fidl::Error>>
        + Send;
    fn r#clock_query_rate(&self, resource: u32, hz_in: u64) -> Self::ClockQueryRateResponseFut;
    type ClockGetRateResponseFut: std::future::Future<Output = Result<SessionClockGetRateResult, fidl::Error>>
        + Send;
    fn r#clock_get_rate(&self, resource: u32) -> Self::ClockGetRateResponseFut;
    type ResetAssertResponseFut: std::future::Future<Output = Result<SessionResetAssertResult, fidl::Error>>
        + Send;
    fn r#reset_assert(&self, resource: u32) -> Self::ResetAssertResponseFut;
    type ResetDeassertResponseFut: std::future::Future<Output = Result<SessionResetDeassertResult, fidl::Error>>
        + Send;
    fn r#reset_deassert(&self, resource: u32) -> Self::ResetDeassertResponseFut;
    type ResetToggleResponseFut: std::future::Future<Output = Result<SessionResetToggleResult, fidl::Error>>
        + Send;
    fn r#reset_toggle(&self, resource: u32) -> Self::ResetToggleResponseFut;
    type ResetStatusResponseFut: std::future::Future<Output = Result<SessionResetStatusResult, fidl::Error>>
        + Send;
    fn r#reset_status(&self, resource: u32) -> Self::ResetStatusResponseFut;
    type SerialReadResponseFut: std::future::Future<Output = Result<SessionSerialReadResult, fidl::Error>>
        + Send;
    fn r#serial_read(&self, resource: u32) -> Self::SerialReadResponseFut;
    type SerialWriteResponseFut: std::future::Future<Output = Result<SessionSerialWriteResult, fidl::Error>>
        + Send;
    fn r#serial_write(&self, resource: u32, data: &[u8]) -> Self::SerialWriteResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SessionSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SessionSynchronousProxy {
    type Proxy = SessionProxy;
    type Protocol = SessionMarker;

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

    /// One policy-checked, audited 32-bit read.
    pub fn r#read32(
        &self,
        mut resource: u32,
        mut offset: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionRead32Result, fidl::Error> {
        let _response = self.client.send_query::<
            SessionRead32Request,
            fidl::encoding::FlexibleResultType<ReadResult, OperationError>,
            SessionMarker,
        >(
            (resource, offset,),
            0x7afec1bfecc09a54,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("read32")?;
        Ok(_response.map(|x| (x.value, x.audit_seq, x.timestamp_ns)))
    }

    /// Bounded snapshot: every item is validated before the first read.
    pub fn r#snapshot(
        &self,
        mut items: &[SnapshotItem],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionSnapshotResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionSnapshotRequest,
            fidl::encoding::FlexibleResultType<SnapshotResult, OperationError>,
            SessionMarker,
        >(
            (items,),
            0x5fa90e4c39fa72e1,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("snapshot")?;
        Ok(_response.map(|x| (x.results, x.complete)))
    }

    /// Reads a bounded audit page so the host can drain incrementally and
    /// detect gaps.
    pub fn r#read_audit(
        &self,
        mut cursor: u64,
        mut limit: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(Vec<AuditEntry>, bool, u64, u64), fidl::Error> {
        let _response = self.client.send_query::<
            SessionReadAuditRequest,
            fidl::encoding::FlexibleType<AuditPage>,
            SessionMarker,
        >(
            (cursor, limit,),
            0x4906c4144e00f4c4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("read_audit")?;
        Ok((
            _response.entries,
            _response.has_oldest,
            _response.oldest_retained,
            _response.next_cursor,
        ))
    }

    /// One policy-checked, audited 32-bit write with optional precondition,
    /// read-modify-write, barrier, and readback.
    pub fn r#write32(
        &self,
        mut resource: u32,
        mut offset: u64,
        mut value: u32,
        mut write_mask: u32,
        mut precondition: Option<&WritePrecondition>,
        mut readback: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionWrite32Result, fidl::Error> {
        let _response = self.client.send_query::<
            SessionWrite32Request,
            fidl::encoding::FlexibleResultType<WriteResult, OperationError>,
            SessionMarker,
        >(
            (resource, offset, value, write_mask, precondition, readback,),
            0x80dcccde698980c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("write32")?;
        Ok(_response.map(|x| (x.readback_value, x.audit_seq, x.timestamp_ns)))
    }

    /// Repeated bounded read until (value & mask) == (expected & mask)
    /// or timeout. Uses asynchronous timers on the driver dispatcher.
    pub fn r#poll32(
        &self,
        mut resource: u32,
        mut offset: u64,
        mut expected: u32,
        mut mask: u32,
        mut interval_ns: i64,
        mut timeout_ns: i64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionPoll32Result, fidl::Error> {
        let _response = self.client.send_query::<
            SessionPoll32Request,
            fidl::encoding::FlexibleResultType<PollResult, OperationError>,
            SessionMarker,
        >(
            (resource, offset, expected, mask, interval_ns, timeout_ns,),
            0x3b9c26d1582fff7d,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("poll32")?;
        Ok(_response.map(|x| (x.value, x.audit_seq, x.timestamp_ns)))
    }

    /// Bounded ordered sequence of operations. Whole-sequence validation
    /// occurs before any hardware operation begins.
    pub fn r#execute_sequence(
        &self,
        mut items: &[SequenceItem],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionExecuteSequenceResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionExecuteSequenceRequest,
            fidl::encoding::FlexibleResultType<SequenceResult, OperationError>,
            SessionMarker,
        >(
            (items,),
            0xf0500bd7555a614,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("execute_sequence")?;
        Ok(_response.map(|x| (x.results, x.complete)))
    }

    /// One policy-checked, audited GPIO read.
    pub fn r#gpio_read(
        &self,
        mut resource: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionGpioReadResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionGpioReadRequest,
            fidl::encoding::FlexibleResultType<GpioReadResult, OperationError>,
            SessionMarker,
        >(
            (resource,),
            0xb01fc817332de51,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("gpio_read")?;
        Ok(_response.map(|x| (x.value, x.audit_seq, x.timestamp_ns)))
    }

    /// One policy-checked, audited GPIO write. Requires mutation lease.
    pub fn r#gpio_write(
        &self,
        mut resource: u32,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionGpioWriteResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionGpioWriteRequest,
            fidl::encoding::FlexibleResultType<GpioWriteResult, OperationError>,
            SessionMarker,
        >(
            (resource, value,),
            0x27cfbd9ffaf5c6e7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("gpio_write")?;
        Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
    }

    /// One policy-checked, audited I2C transfer. Non-empty write requires mutation lease.
    pub fn r#i2c_transfer(
        &self,
        mut resource: u32,
        mut write_data: &[u8],
        mut read_length: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionI2cTransferResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionI2cTransferRequest,
            fidl::encoding::FlexibleResultType<I2cTransferResult, OperationError>,
            SessionMarker,
        >(
            (resource, write_data, read_length,),
            0x67016bc41336f298,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("i2c_transfer")?;
        Ok(_response.map(|x| (x.read_data, x.audit_seq, x.timestamp_ns)))
    }

    /// One policy-checked, audited SPI transmit. Requires mutation lease.
    pub fn r#spi_transmit(
        &self,
        mut resource: u32,
        mut tx_data: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionSpiTransmitResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionSpiTransmitRequest,
            fidl::encoding::FlexibleResultType<SpiTransmitResult, OperationError>,
            SessionMarker,
        >(
            (resource, tx_data,),
            0x3429847e2877d4d7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("spi_transmit")?;
        Ok(_response.map(|x| (x.rx_data, x.audit_seq, x.timestamp_ns)))
    }

    /// Opens a typed GPIO endpoint bound to this session.
    pub fn r#open_gpio(
        &self,
        mut resource: u32,
        mut endpoint: fidl::endpoints::ServerEnd<GpioEndpointMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionOpenGpioResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionOpenGpioRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, OperationError>,
            SessionMarker,
        >(
            (resource, endpoint,),
            0x5bd9f23cba94897,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("open_gpio")?;
        Ok(_response.map(|x| x))
    }

    /// Opens a typed I2C endpoint bound to this session.
    pub fn r#open_i2c(
        &self,
        mut resource: u32,
        mut endpoint: fidl::endpoints::ServerEnd<I2cEndpointMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionOpenI2cResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionOpenI2cRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, OperationError>,
            SessionMarker,
        >(
            (resource, endpoint,),
            0x17ba936a44a14633,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("open_i2c")?;
        Ok(_response.map(|x| x))
    }

    /// Opens a typed SPI endpoint bound to this session.
    pub fn r#open_spi(
        &self,
        mut resource: u32,
        mut endpoint: fidl::endpoints::ServerEnd<SpiEndpointMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionOpenSpiResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionOpenSpiRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, OperationError>,
            SessionMarker,
        >(
            (resource, endpoint,),
            0x3ee7e7cea84dfc9d,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("open_spi")?;
        Ok(_response.map(|x| x))
    }

    /// Observes an interrupt event. Bounded hanging request that yields when
    /// the interrupt sequence exceeds `after_sequence` or upon timeout.
    pub fn r#wait_for_interrupt(
        &self,
        mut resource: u32,
        mut after_sequence: u64,
        mut timeout_ns: i64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionWaitForInterruptResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionWaitForInterruptRequest,
            fidl::encoding::FlexibleResultType<InterruptResult, OperationError>,
            SessionMarker,
        >(
            (resource, after_sequence, timeout_ns,),
            0x276a31c24a164cdb,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("wait_for_interrupt")?;
        Ok(_response.map(|x| (x.resource, x.sequence, x.count, x.timestamp_ns, x.coalesced_count)))
    }

    /// One policy-checked, audited Clock enable. Requires mutation lease.
    pub fn r#clock_enable(
        &self,
        mut resource: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionClockEnableResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionClockEnableRequest,
            fidl::encoding::FlexibleResultType<ClockEnableResult, OperationError>,
            SessionMarker,
        >(
            (resource,),
            0x774b563ebff897eb,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("clock_enable")?;
        Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
    }

    /// One policy-checked, audited Clock disable. Requires mutation lease.
    pub fn r#clock_disable(
        &self,
        mut resource: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionClockDisableResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionClockDisableRequest,
            fidl::encoding::FlexibleResultType<ClockDisableResult, OperationError>,
            SessionMarker,
        >(
            (resource,),
            0x642c11d03db8b873,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("clock_disable")?;
        Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
    }

    /// One policy-checked, audited Clock is_enabled query.
    pub fn r#clock_is_enabled(
        &self,
        mut resource: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionClockIsEnabledResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionClockIsEnabledRequest,
            fidl::encoding::FlexibleResultType<ClockIsEnabledResult, OperationError>,
            SessionMarker,
        >(
            (resource,),
            0x36a033a7a1322174,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("clock_is_enabled")?;
        Ok(_response.map(|x| (x.enabled, x.audit_seq, x.timestamp_ns)))
    }

    /// One policy-checked, audited Clock set_rate. Requires mutation lease.
    pub fn r#clock_set_rate(
        &self,
        mut resource: u32,
        mut hz: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionClockSetRateResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionClockSetRateRequest,
            fidl::encoding::FlexibleResultType<ClockSetRateResult, OperationError>,
            SessionMarker,
        >(
            (resource, hz,),
            0x4dbc4012d4289048,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("clock_set_rate")?;
        Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
    }

    /// One policy-checked, audited Clock query_supported_rate query.
    pub fn r#clock_query_rate(
        &self,
        mut resource: u32,
        mut hz_in: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionClockQueryRateResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionClockQueryRateRequest,
            fidl::encoding::FlexibleResultType<ClockQueryRateResult, OperationError>,
            SessionMarker,
        >(
            (resource, hz_in,),
            0x11b9fe61ad09ff5e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("clock_query_rate")?;
        Ok(_response.map(|x| (x.hz_out, x.audit_seq, x.timestamp_ns)))
    }

    /// One policy-checked, audited Clock get_rate query.
    pub fn r#clock_get_rate(
        &self,
        mut resource: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionClockGetRateResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionClockGetRateRequest,
            fidl::encoding::FlexibleResultType<ClockGetRateResult, OperationError>,
            SessionMarker,
        >(
            (resource,),
            0x4f3c0e2259e5e46,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("clock_get_rate")?;
        Ok(_response.map(|x| (x.hz, x.audit_seq, x.timestamp_ns)))
    }

    /// One policy-checked, audited Reset assert. Requires mutation lease.
    pub fn r#reset_assert(
        &self,
        mut resource: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionResetAssertResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionResetAssertRequest,
            fidl::encoding::FlexibleResultType<ResetAssertResult, OperationError>,
            SessionMarker,
        >(
            (resource,),
            0x5788d4842384c111,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("reset_assert")?;
        Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
    }

    /// One policy-checked, audited Reset deassert. Requires mutation lease.
    pub fn r#reset_deassert(
        &self,
        mut resource: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionResetDeassertResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionResetDeassertRequest,
            fidl::encoding::FlexibleResultType<ResetDeassertResult, OperationError>,
            SessionMarker,
        >(
            (resource,),
            0x632c13fc5e08d3e2,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("reset_deassert")?;
        Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
    }

    /// One policy-checked, audited Reset toggle. Requires mutation lease.
    pub fn r#reset_toggle(
        &self,
        mut resource: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionResetToggleResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionResetToggleRequest,
            fidl::encoding::FlexibleResultType<ResetToggleResult, OperationError>,
            SessionMarker,
        >(
            (resource,),
            0x2b2b14cb6a5e4c98,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("reset_toggle")?;
        Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
    }

    /// One policy-checked, audited Reset status query.
    pub fn r#reset_status(
        &self,
        mut resource: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionResetStatusResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionResetStatusRequest,
            fidl::encoding::FlexibleResultType<ResetStatusResult, OperationError>,
            SessionMarker,
        >(
            (resource,),
            0x1790a96ce5f3b3d9,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("reset_status")?;
        Ok(_response.map(|x| (x.asserted, x.audit_seq, x.timestamp_ns)))
    }

    /// One policy-checked, audited Serial read.
    pub fn r#serial_read(
        &self,
        mut resource: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionSerialReadResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionSerialReadRequest,
            fidl::encoding::FlexibleResultType<SerialReadResult, OperationError>,
            SessionMarker,
        >(
            (resource,),
            0x2b76818805a351fd,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("serial_read")?;
        Ok(_response.map(|x| (x.data, x.audit_seq, x.timestamp_ns)))
    }

    /// One policy-checked, audited Serial write. Requires mutation lease.
    pub fn r#serial_write(
        &self,
        mut resource: u32,
        mut data: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SessionSerialWriteResult, fidl::Error> {
        let _response = self.client.send_query::<
            SessionSerialWriteRequest,
            fidl::encoding::FlexibleResultType<SerialWriteResult, OperationError>,
            SessionMarker,
        >(
            (resource, data,),
            0x5345a3e2317a792f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SessionMarker>("serial_write")?;
        Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for SessionProxy {
    type Protocol = SessionMarker;

    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 SessionProxy {
    /// Create a new Proxy for fuchsia.driver.lab/Session.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <SessionMarker 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) -> SessionEventStream {
        SessionEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// One policy-checked, audited 32-bit read.
    pub fn r#read32(
        &self,
        mut resource: u32,
        mut offset: u64,
    ) -> fidl::client::QueryResponseFut<
        SessionRead32Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#read32(self, resource, offset)
    }

    /// Bounded snapshot: every item is validated before the first read.
    pub fn r#snapshot(
        &self,
        mut items: &[SnapshotItem],
    ) -> fidl::client::QueryResponseFut<
        SessionSnapshotResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#snapshot(self, items)
    }

    /// Reads a bounded audit page so the host can drain incrementally and
    /// detect gaps.
    pub fn r#read_audit(
        &self,
        mut cursor: u64,
        mut limit: u32,
    ) -> fidl::client::QueryResponseFut<
        (Vec<AuditEntry>, bool, u64, u64),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#read_audit(self, cursor, limit)
    }

    /// One policy-checked, audited 32-bit write with optional precondition,
    /// read-modify-write, barrier, and readback.
    pub fn r#write32(
        &self,
        mut resource: u32,
        mut offset: u64,
        mut value: u32,
        mut write_mask: u32,
        mut precondition: Option<&WritePrecondition>,
        mut readback: bool,
    ) -> fidl::client::QueryResponseFut<
        SessionWrite32Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#write32(
            self,
            resource,
            offset,
            value,
            write_mask,
            precondition,
            readback,
        )
    }

    /// Repeated bounded read until (value & mask) == (expected & mask)
    /// or timeout. Uses asynchronous timers on the driver dispatcher.
    pub fn r#poll32(
        &self,
        mut resource: u32,
        mut offset: u64,
        mut expected: u32,
        mut mask: u32,
        mut interval_ns: i64,
        mut timeout_ns: i64,
    ) -> fidl::client::QueryResponseFut<
        SessionPoll32Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#poll32(
            self,
            resource,
            offset,
            expected,
            mask,
            interval_ns,
            timeout_ns,
        )
    }

    /// Bounded ordered sequence of operations. Whole-sequence validation
    /// occurs before any hardware operation begins.
    pub fn r#execute_sequence(
        &self,
        mut items: &[SequenceItem],
    ) -> fidl::client::QueryResponseFut<
        SessionExecuteSequenceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#execute_sequence(self, items)
    }

    /// One policy-checked, audited GPIO read.
    pub fn r#gpio_read(
        &self,
        mut resource: u32,
    ) -> fidl::client::QueryResponseFut<
        SessionGpioReadResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#gpio_read(self, resource)
    }

    /// One policy-checked, audited GPIO write. Requires mutation lease.
    pub fn r#gpio_write(
        &self,
        mut resource: u32,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        SessionGpioWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#gpio_write(self, resource, value)
    }

    /// One policy-checked, audited I2C transfer. Non-empty write requires mutation lease.
    pub fn r#i2c_transfer(
        &self,
        mut resource: u32,
        mut write_data: &[u8],
        mut read_length: u32,
    ) -> fidl::client::QueryResponseFut<
        SessionI2cTransferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#i2c_transfer(self, resource, write_data, read_length)
    }

    /// One policy-checked, audited SPI transmit. Requires mutation lease.
    pub fn r#spi_transmit(
        &self,
        mut resource: u32,
        mut tx_data: &[u8],
    ) -> fidl::client::QueryResponseFut<
        SessionSpiTransmitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#spi_transmit(self, resource, tx_data)
    }

    /// Opens a typed GPIO endpoint bound to this session.
    pub fn r#open_gpio(
        &self,
        mut resource: u32,
        mut endpoint: fidl::endpoints::ServerEnd<GpioEndpointMarker>,
    ) -> fidl::client::QueryResponseFut<
        SessionOpenGpioResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#open_gpio(self, resource, endpoint)
    }

    /// Opens a typed I2C endpoint bound to this session.
    pub fn r#open_i2c(
        &self,
        mut resource: u32,
        mut endpoint: fidl::endpoints::ServerEnd<I2cEndpointMarker>,
    ) -> fidl::client::QueryResponseFut<
        SessionOpenI2cResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#open_i2c(self, resource, endpoint)
    }

    /// Opens a typed SPI endpoint bound to this session.
    pub fn r#open_spi(
        &self,
        mut resource: u32,
        mut endpoint: fidl::endpoints::ServerEnd<SpiEndpointMarker>,
    ) -> fidl::client::QueryResponseFut<
        SessionOpenSpiResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#open_spi(self, resource, endpoint)
    }

    /// Observes an interrupt event. Bounded hanging request that yields when
    /// the interrupt sequence exceeds `after_sequence` or upon timeout.
    pub fn r#wait_for_interrupt(
        &self,
        mut resource: u32,
        mut after_sequence: u64,
        mut timeout_ns: i64,
    ) -> fidl::client::QueryResponseFut<
        SessionWaitForInterruptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#wait_for_interrupt(self, resource, after_sequence, timeout_ns)
    }

    /// One policy-checked, audited Clock enable. Requires mutation lease.
    pub fn r#clock_enable(
        &self,
        mut resource: u32,
    ) -> fidl::client::QueryResponseFut<
        SessionClockEnableResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#clock_enable(self, resource)
    }

    /// One policy-checked, audited Clock disable. Requires mutation lease.
    pub fn r#clock_disable(
        &self,
        mut resource: u32,
    ) -> fidl::client::QueryResponseFut<
        SessionClockDisableResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#clock_disable(self, resource)
    }

    /// One policy-checked, audited Clock is_enabled query.
    pub fn r#clock_is_enabled(
        &self,
        mut resource: u32,
    ) -> fidl::client::QueryResponseFut<
        SessionClockIsEnabledResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#clock_is_enabled(self, resource)
    }

    /// One policy-checked, audited Clock set_rate. Requires mutation lease.
    pub fn r#clock_set_rate(
        &self,
        mut resource: u32,
        mut hz: u64,
    ) -> fidl::client::QueryResponseFut<
        SessionClockSetRateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#clock_set_rate(self, resource, hz)
    }

    /// One policy-checked, audited Clock query_supported_rate query.
    pub fn r#clock_query_rate(
        &self,
        mut resource: u32,
        mut hz_in: u64,
    ) -> fidl::client::QueryResponseFut<
        SessionClockQueryRateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#clock_query_rate(self, resource, hz_in)
    }

    /// One policy-checked, audited Clock get_rate query.
    pub fn r#clock_get_rate(
        &self,
        mut resource: u32,
    ) -> fidl::client::QueryResponseFut<
        SessionClockGetRateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#clock_get_rate(self, resource)
    }

    /// One policy-checked, audited Reset assert. Requires mutation lease.
    pub fn r#reset_assert(
        &self,
        mut resource: u32,
    ) -> fidl::client::QueryResponseFut<
        SessionResetAssertResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#reset_assert(self, resource)
    }

    /// One policy-checked, audited Reset deassert. Requires mutation lease.
    pub fn r#reset_deassert(
        &self,
        mut resource: u32,
    ) -> fidl::client::QueryResponseFut<
        SessionResetDeassertResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#reset_deassert(self, resource)
    }

    /// One policy-checked, audited Reset toggle. Requires mutation lease.
    pub fn r#reset_toggle(
        &self,
        mut resource: u32,
    ) -> fidl::client::QueryResponseFut<
        SessionResetToggleResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#reset_toggle(self, resource)
    }

    /// One policy-checked, audited Reset status query.
    pub fn r#reset_status(
        &self,
        mut resource: u32,
    ) -> fidl::client::QueryResponseFut<
        SessionResetStatusResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#reset_status(self, resource)
    }

    /// One policy-checked, audited Serial read.
    pub fn r#serial_read(
        &self,
        mut resource: u32,
    ) -> fidl::client::QueryResponseFut<
        SessionSerialReadResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#serial_read(self, resource)
    }

    /// One policy-checked, audited Serial write. Requires mutation lease.
    pub fn r#serial_write(
        &self,
        mut resource: u32,
        mut data: &[u8],
    ) -> fidl::client::QueryResponseFut<
        SessionSerialWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SessionProxyInterface::r#serial_write(self, resource, data)
    }
}

impl SessionProxyInterface for SessionProxy {
    type Read32ResponseFut = fidl::client::QueryResponseFut<
        SessionRead32Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read32(&self, mut resource: u32, mut offset: u64) -> Self::Read32ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionRead32Result, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ReadResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7afec1bfecc09a54,
            >(_buf?)?
            .into_result::<SessionMarker>("read32")?;
            Ok(_response.map(|x| (x.value, x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionRead32Request, SessionRead32Result>(
            (resource, offset),
            0x7afec1bfecc09a54,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SnapshotResponseFut = fidl::client::QueryResponseFut<
        SessionSnapshotResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#snapshot(&self, mut items: &[SnapshotItem]) -> Self::SnapshotResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionSnapshotResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<SnapshotResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5fa90e4c39fa72e1,
            >(_buf?)?
            .into_result::<SessionMarker>("snapshot")?;
            Ok(_response.map(|x| (x.results, x.complete)))
        }
        self.client.send_query_and_decode::<SessionSnapshotRequest, SessionSnapshotResult>(
            (items,),
            0x5fa90e4c39fa72e1,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ReadAuditResponseFut = fidl::client::QueryResponseFut<
        (Vec<AuditEntry>, bool, u64, u64),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_audit(&self, mut cursor: u64, mut limit: u32) -> Self::ReadAuditResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(Vec<AuditEntry>, bool, u64, u64), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<AuditPage>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4906c4144e00f4c4,
            >(_buf?)?
            .into_result::<SessionMarker>("read_audit")?;
            Ok((
                _response.entries,
                _response.has_oldest,
                _response.oldest_retained,
                _response.next_cursor,
            ))
        }
        self.client
            .send_query_and_decode::<SessionReadAuditRequest, (Vec<AuditEntry>, bool, u64, u64)>(
                (cursor, limit),
                0x4906c4144e00f4c4,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type Write32ResponseFut = fidl::client::QueryResponseFut<
        SessionWrite32Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write32(
        &self,
        mut resource: u32,
        mut offset: u64,
        mut value: u32,
        mut write_mask: u32,
        mut precondition: Option<&WritePrecondition>,
        mut readback: bool,
    ) -> Self::Write32ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionWrite32Result, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<WriteResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x80dcccde698980c,
            >(_buf?)?
            .into_result::<SessionMarker>("write32")?;
            Ok(_response.map(|x| (x.readback_value, x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionWrite32Request, SessionWrite32Result>(
            (resource, offset, value, write_mask, precondition, readback),
            0x80dcccde698980c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type Poll32ResponseFut = fidl::client::QueryResponseFut<
        SessionPoll32Result,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#poll32(
        &self,
        mut resource: u32,
        mut offset: u64,
        mut expected: u32,
        mut mask: u32,
        mut interval_ns: i64,
        mut timeout_ns: i64,
    ) -> Self::Poll32ResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionPoll32Result, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<PollResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3b9c26d1582fff7d,
            >(_buf?)?
            .into_result::<SessionMarker>("poll32")?;
            Ok(_response.map(|x| (x.value, x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionPoll32Request, SessionPoll32Result>(
            (resource, offset, expected, mask, interval_ns, timeout_ns),
            0x3b9c26d1582fff7d,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ExecuteSequenceResponseFut = fidl::client::QueryResponseFut<
        SessionExecuteSequenceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#execute_sequence(&self, mut items: &[SequenceItem]) -> Self::ExecuteSequenceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionExecuteSequenceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<SequenceResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xf0500bd7555a614,
            >(_buf?)?
            .into_result::<SessionMarker>("execute_sequence")?;
            Ok(_response.map(|x| (x.results, x.complete)))
        }
        self.client
            .send_query_and_decode::<SessionExecuteSequenceRequest, SessionExecuteSequenceResult>(
                (items,),
                0xf0500bd7555a614,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type GpioReadResponseFut = fidl::client::QueryResponseFut<
        SessionGpioReadResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#gpio_read(&self, mut resource: u32) -> Self::GpioReadResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionGpioReadResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<GpioReadResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xb01fc817332de51,
            >(_buf?)?
            .into_result::<SessionMarker>("gpio_read")?;
            Ok(_response.map(|x| (x.value, x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionGpioReadRequest, SessionGpioReadResult>(
            (resource,),
            0xb01fc817332de51,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GpioWriteResponseFut = fidl::client::QueryResponseFut<
        SessionGpioWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#gpio_write(&self, mut resource: u32, mut value: bool) -> Self::GpioWriteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionGpioWriteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<GpioWriteResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x27cfbd9ffaf5c6e7,
            >(_buf?)?
            .into_result::<SessionMarker>("gpio_write")?;
            Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionGpioWriteRequest, SessionGpioWriteResult>(
            (resource, value),
            0x27cfbd9ffaf5c6e7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type I2cTransferResponseFut = fidl::client::QueryResponseFut<
        SessionI2cTransferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#i2c_transfer(
        &self,
        mut resource: u32,
        mut write_data: &[u8],
        mut read_length: u32,
    ) -> Self::I2cTransferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionI2cTransferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<I2cTransferResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x67016bc41336f298,
            >(_buf?)?
            .into_result::<SessionMarker>("i2c_transfer")?;
            Ok(_response.map(|x| (x.read_data, x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionI2cTransferRequest, SessionI2cTransferResult>(
            (resource, write_data, read_length),
            0x67016bc41336f298,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SpiTransmitResponseFut = fidl::client::QueryResponseFut<
        SessionSpiTransmitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#spi_transmit(
        &self,
        mut resource: u32,
        mut tx_data: &[u8],
    ) -> Self::SpiTransmitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionSpiTransmitResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<SpiTransmitResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3429847e2877d4d7,
            >(_buf?)?
            .into_result::<SessionMarker>("spi_transmit")?;
            Ok(_response.map(|x| (x.rx_data, x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionSpiTransmitRequest, SessionSpiTransmitResult>(
            (resource, tx_data),
            0x3429847e2877d4d7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type OpenGpioResponseFut = fidl::client::QueryResponseFut<
        SessionOpenGpioResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_gpio(
        &self,
        mut resource: u32,
        mut endpoint: fidl::endpoints::ServerEnd<GpioEndpointMarker>,
    ) -> Self::OpenGpioResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionOpenGpioResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5bd9f23cba94897,
            >(_buf?)?
            .into_result::<SessionMarker>("open_gpio")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<SessionOpenGpioRequest, SessionOpenGpioResult>(
            (resource, endpoint),
            0x5bd9f23cba94897,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type OpenI2cResponseFut = fidl::client::QueryResponseFut<
        SessionOpenI2cResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_i2c(
        &self,
        mut resource: u32,
        mut endpoint: fidl::endpoints::ServerEnd<I2cEndpointMarker>,
    ) -> Self::OpenI2cResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionOpenI2cResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x17ba936a44a14633,
            >(_buf?)?
            .into_result::<SessionMarker>("open_i2c")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<SessionOpenI2cRequest, SessionOpenI2cResult>(
            (resource, endpoint),
            0x17ba936a44a14633,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type OpenSpiResponseFut = fidl::client::QueryResponseFut<
        SessionOpenSpiResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open_spi(
        &self,
        mut resource: u32,
        mut endpoint: fidl::endpoints::ServerEnd<SpiEndpointMarker>,
    ) -> Self::OpenSpiResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionOpenSpiResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3ee7e7cea84dfc9d,
            >(_buf?)?
            .into_result::<SessionMarker>("open_spi")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<SessionOpenSpiRequest, SessionOpenSpiResult>(
            (resource, endpoint),
            0x3ee7e7cea84dfc9d,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type WaitForInterruptResponseFut = fidl::client::QueryResponseFut<
        SessionWaitForInterruptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#wait_for_interrupt(
        &self,
        mut resource: u32,
        mut after_sequence: u64,
        mut timeout_ns: i64,
    ) -> Self::WaitForInterruptResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionWaitForInterruptResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<InterruptResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x276a31c24a164cdb,
            >(_buf?)?
            .into_result::<SessionMarker>("wait_for_interrupt")?;
            Ok(_response
                .map(|x| (x.resource, x.sequence, x.count, x.timestamp_ns, x.coalesced_count)))
        }
        self.client
            .send_query_and_decode::<SessionWaitForInterruptRequest, SessionWaitForInterruptResult>(
                (resource, after_sequence, timeout_ns),
                0x276a31c24a164cdb,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type ClockEnableResponseFut = fidl::client::QueryResponseFut<
        SessionClockEnableResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#clock_enable(&self, mut resource: u32) -> Self::ClockEnableResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionClockEnableResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ClockEnableResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x774b563ebff897eb,
            >(_buf?)?
            .into_result::<SessionMarker>("clock_enable")?;
            Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionClockEnableRequest, SessionClockEnableResult>(
            (resource,),
            0x774b563ebff897eb,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ClockDisableResponseFut = fidl::client::QueryResponseFut<
        SessionClockDisableResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#clock_disable(&self, mut resource: u32) -> Self::ClockDisableResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionClockDisableResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ClockDisableResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x642c11d03db8b873,
            >(_buf?)?
            .into_result::<SessionMarker>("clock_disable")?;
            Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionClockDisableRequest, SessionClockDisableResult>(
            (resource,),
            0x642c11d03db8b873,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ClockIsEnabledResponseFut = fidl::client::QueryResponseFut<
        SessionClockIsEnabledResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#clock_is_enabled(&self, mut resource: u32) -> Self::ClockIsEnabledResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionClockIsEnabledResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ClockIsEnabledResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x36a033a7a1322174,
            >(_buf?)?
            .into_result::<SessionMarker>("clock_is_enabled")?;
            Ok(_response.map(|x| (x.enabled, x.audit_seq, x.timestamp_ns)))
        }
        self.client
            .send_query_and_decode::<SessionClockIsEnabledRequest, SessionClockIsEnabledResult>(
                (resource,),
                0x36a033a7a1322174,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type ClockSetRateResponseFut = fidl::client::QueryResponseFut<
        SessionClockSetRateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#clock_set_rate(&self, mut resource: u32, mut hz: u64) -> Self::ClockSetRateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionClockSetRateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ClockSetRateResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4dbc4012d4289048,
            >(_buf?)?
            .into_result::<SessionMarker>("clock_set_rate")?;
            Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionClockSetRateRequest, SessionClockSetRateResult>(
            (resource, hz),
            0x4dbc4012d4289048,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ClockQueryRateResponseFut = fidl::client::QueryResponseFut<
        SessionClockQueryRateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#clock_query_rate(
        &self,
        mut resource: u32,
        mut hz_in: u64,
    ) -> Self::ClockQueryRateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionClockQueryRateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ClockQueryRateResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x11b9fe61ad09ff5e,
            >(_buf?)?
            .into_result::<SessionMarker>("clock_query_rate")?;
            Ok(_response.map(|x| (x.hz_out, x.audit_seq, x.timestamp_ns)))
        }
        self.client
            .send_query_and_decode::<SessionClockQueryRateRequest, SessionClockQueryRateResult>(
                (resource, hz_in),
                0x11b9fe61ad09ff5e,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type ClockGetRateResponseFut = fidl::client::QueryResponseFut<
        SessionClockGetRateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#clock_get_rate(&self, mut resource: u32) -> Self::ClockGetRateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionClockGetRateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ClockGetRateResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4f3c0e2259e5e46,
            >(_buf?)?
            .into_result::<SessionMarker>("clock_get_rate")?;
            Ok(_response.map(|x| (x.hz, x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionClockGetRateRequest, SessionClockGetRateResult>(
            (resource,),
            0x4f3c0e2259e5e46,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ResetAssertResponseFut = fidl::client::QueryResponseFut<
        SessionResetAssertResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#reset_assert(&self, mut resource: u32) -> Self::ResetAssertResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionResetAssertResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ResetAssertResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5788d4842384c111,
            >(_buf?)?
            .into_result::<SessionMarker>("reset_assert")?;
            Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionResetAssertRequest, SessionResetAssertResult>(
            (resource,),
            0x5788d4842384c111,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ResetDeassertResponseFut = fidl::client::QueryResponseFut<
        SessionResetDeassertResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#reset_deassert(&self, mut resource: u32) -> Self::ResetDeassertResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionResetDeassertResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ResetDeassertResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x632c13fc5e08d3e2,
            >(_buf?)?
            .into_result::<SessionMarker>("reset_deassert")?;
            Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
        }
        self.client
            .send_query_and_decode::<SessionResetDeassertRequest, SessionResetDeassertResult>(
                (resource,),
                0x632c13fc5e08d3e2,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type ResetToggleResponseFut = fidl::client::QueryResponseFut<
        SessionResetToggleResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#reset_toggle(&self, mut resource: u32) -> Self::ResetToggleResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionResetToggleResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ResetToggleResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2b2b14cb6a5e4c98,
            >(_buf?)?
            .into_result::<SessionMarker>("reset_toggle")?;
            Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionResetToggleRequest, SessionResetToggleResult>(
            (resource,),
            0x2b2b14cb6a5e4c98,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ResetStatusResponseFut = fidl::client::QueryResponseFut<
        SessionResetStatusResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#reset_status(&self, mut resource: u32) -> Self::ResetStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionResetStatusResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ResetStatusResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1790a96ce5f3b3d9,
            >(_buf?)?
            .into_result::<SessionMarker>("reset_status")?;
            Ok(_response.map(|x| (x.asserted, x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionResetStatusRequest, SessionResetStatusResult>(
            (resource,),
            0x1790a96ce5f3b3d9,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SerialReadResponseFut = fidl::client::QueryResponseFut<
        SessionSerialReadResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#serial_read(&self, mut resource: u32) -> Self::SerialReadResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionSerialReadResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<SerialReadResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2b76818805a351fd,
            >(_buf?)?
            .into_result::<SessionMarker>("serial_read")?;
            Ok(_response.map(|x| (x.data, x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionSerialReadRequest, SessionSerialReadResult>(
            (resource,),
            0x2b76818805a351fd,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SerialWriteResponseFut = fidl::client::QueryResponseFut<
        SessionSerialWriteResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#serial_write(&self, mut resource: u32, mut data: &[u8]) -> Self::SerialWriteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SessionSerialWriteResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<SerialWriteResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5345a3e2317a792f,
            >(_buf?)?
            .into_result::<SessionMarker>("serial_write")?;
            Ok(_response.map(|x| (x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SessionSerialWriteRequest, SessionSerialWriteResult>(
            (resource, data),
            0x5345a3e2317a792f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.driver.lab/Session.
pub struct SessionRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for SessionRequestStream {
    type Protocol = SessionMarker;
    type ControlHandle = SessionControlHandle;

    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 {
        SessionControlHandle { 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 SessionRequestStream {
    type Item = Result<SessionRequest, 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 SessionRequestStream 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 {
                    0x7afec1bfecc09a54 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionRead32Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionRead32Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::Read32 {
                            resource: req.resource,
                            offset: req.offset,

                            responder: SessionRead32Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5fa90e4c39fa72e1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionSnapshotRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionSnapshotRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::Snapshot {
                            items: req.items,

                            responder: SessionSnapshotResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4906c4144e00f4c4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionReadAuditRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionReadAuditRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::ReadAudit {
                            cursor: req.cursor,
                            limit: req.limit,

                            responder: SessionReadAuditResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x80dcccde698980c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionWrite32Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionWrite32Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::Write32 {
                            resource: req.resource,
                            offset: req.offset,
                            value: req.value,
                            write_mask: req.write_mask,
                            precondition: req.precondition,
                            readback: req.readback,

                            responder: SessionWrite32Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3b9c26d1582fff7d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionPoll32Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionPoll32Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::Poll32 {
                            resource: req.resource,
                            offset: req.offset,
                            expected: req.expected,
                            mask: req.mask,
                            interval_ns: req.interval_ns,
                            timeout_ns: req.timeout_ns,

                            responder: SessionPoll32Responder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xf0500bd7555a614 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionExecuteSequenceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionExecuteSequenceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::ExecuteSequence {
                            items: req.items,

                            responder: SessionExecuteSequenceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xb01fc817332de51 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionGpioReadRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionGpioReadRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::GpioRead {
                            resource: req.resource,

                            responder: SessionGpioReadResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x27cfbd9ffaf5c6e7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionGpioWriteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionGpioWriteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::GpioWrite {
                            resource: req.resource,
                            value: req.value,

                            responder: SessionGpioWriteResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x67016bc41336f298 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionI2cTransferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionI2cTransferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::I2cTransfer {
                            resource: req.resource,
                            write_data: req.write_data,
                            read_length: req.read_length,

                            responder: SessionI2cTransferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3429847e2877d4d7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionSpiTransmitRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionSpiTransmitRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::SpiTransmit {
                            resource: req.resource,
                            tx_data: req.tx_data,

                            responder: SessionSpiTransmitResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5bd9f23cba94897 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionOpenGpioRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionOpenGpioRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::OpenGpio {
                            resource: req.resource,
                            endpoint: req.endpoint,

                            responder: SessionOpenGpioResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x17ba936a44a14633 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionOpenI2cRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionOpenI2cRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::OpenI2c {
                            resource: req.resource,
                            endpoint: req.endpoint,

                            responder: SessionOpenI2cResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3ee7e7cea84dfc9d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionOpenSpiRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionOpenSpiRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::OpenSpi {
                            resource: req.resource,
                            endpoint: req.endpoint,

                            responder: SessionOpenSpiResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x276a31c24a164cdb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionWaitForInterruptRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionWaitForInterruptRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::WaitForInterrupt {
                            resource: req.resource,
                            after_sequence: req.after_sequence,
                            timeout_ns: req.timeout_ns,

                            responder: SessionWaitForInterruptResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x774b563ebff897eb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionClockEnableRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionClockEnableRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::ClockEnable {
                            resource: req.resource,

                            responder: SessionClockEnableResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x642c11d03db8b873 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionClockDisableRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionClockDisableRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::ClockDisable {
                            resource: req.resource,

                            responder: SessionClockDisableResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x36a033a7a1322174 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionClockIsEnabledRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionClockIsEnabledRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::ClockIsEnabled {
                            resource: req.resource,

                            responder: SessionClockIsEnabledResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4dbc4012d4289048 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionClockSetRateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionClockSetRateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::ClockSetRate {
                            resource: req.resource,
                            hz: req.hz,

                            responder: SessionClockSetRateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x11b9fe61ad09ff5e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionClockQueryRateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionClockQueryRateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::ClockQueryRate {
                            resource: req.resource,
                            hz_in: req.hz_in,

                            responder: SessionClockQueryRateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4f3c0e2259e5e46 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionClockGetRateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionClockGetRateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::ClockGetRate {
                            resource: req.resource,

                            responder: SessionClockGetRateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5788d4842384c111 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionResetAssertRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionResetAssertRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::ResetAssert {
                            resource: req.resource,

                            responder: SessionResetAssertResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x632c13fc5e08d3e2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionResetDeassertRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionResetDeassertRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::ResetDeassert {
                            resource: req.resource,

                            responder: SessionResetDeassertResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2b2b14cb6a5e4c98 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionResetToggleRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionResetToggleRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::ResetToggle {
                            resource: req.resource,

                            responder: SessionResetToggleResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1790a96ce5f3b3d9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionResetStatusRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionResetStatusRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::ResetStatus {
                            resource: req.resource,

                            responder: SessionResetStatusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2b76818805a351fd => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionSerialReadRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionSerialReadRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::SerialRead {
                            resource: req.resource,

                            responder: SessionSerialReadResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5345a3e2317a792f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SessionSerialWriteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SessionSerialWriteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SessionControlHandle { inner: this.inner.clone() };
                        Ok(SessionRequest::SerialWrite {
                            resource: req.resource,
                            data: req.data,

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

/// One experiment session. Closing the channel closes the session,
/// cancels its pending work, and releases the mutation lease.
#[derive(Debug)]
pub enum SessionRequest {
    /// One policy-checked, audited 32-bit read.
    Read32 { resource: u32, offset: u64, responder: SessionRead32Responder },
    /// Bounded snapshot: every item is validated before the first read.
    Snapshot { items: Vec<SnapshotItem>, responder: SessionSnapshotResponder },
    /// Reads a bounded audit page so the host can drain incrementally and
    /// detect gaps.
    ReadAudit { cursor: u64, limit: u32, responder: SessionReadAuditResponder },
    /// One policy-checked, audited 32-bit write with optional precondition,
    /// read-modify-write, barrier, and readback.
    Write32 {
        resource: u32,
        offset: u64,
        value: u32,
        write_mask: u32,
        precondition: Option<Box<WritePrecondition>>,
        readback: bool,
        responder: SessionWrite32Responder,
    },
    /// Repeated bounded read until (value & mask) == (expected & mask)
    /// or timeout. Uses asynchronous timers on the driver dispatcher.
    Poll32 {
        resource: u32,
        offset: u64,
        expected: u32,
        mask: u32,
        interval_ns: i64,
        timeout_ns: i64,
        responder: SessionPoll32Responder,
    },
    /// Bounded ordered sequence of operations. Whole-sequence validation
    /// occurs before any hardware operation begins.
    ExecuteSequence { items: Vec<SequenceItem>, responder: SessionExecuteSequenceResponder },
    /// One policy-checked, audited GPIO read.
    GpioRead { resource: u32, responder: SessionGpioReadResponder },
    /// One policy-checked, audited GPIO write. Requires mutation lease.
    GpioWrite { resource: u32, value: bool, responder: SessionGpioWriteResponder },
    /// One policy-checked, audited I2C transfer. Non-empty write requires mutation lease.
    I2cTransfer {
        resource: u32,
        write_data: Vec<u8>,
        read_length: u32,
        responder: SessionI2cTransferResponder,
    },
    /// One policy-checked, audited SPI transmit. Requires mutation lease.
    SpiTransmit { resource: u32, tx_data: Vec<u8>, responder: SessionSpiTransmitResponder },
    /// Opens a typed GPIO endpoint bound to this session.
    OpenGpio {
        resource: u32,
        endpoint: fidl::endpoints::ServerEnd<GpioEndpointMarker>,
        responder: SessionOpenGpioResponder,
    },
    /// Opens a typed I2C endpoint bound to this session.
    OpenI2c {
        resource: u32,
        endpoint: fidl::endpoints::ServerEnd<I2cEndpointMarker>,
        responder: SessionOpenI2cResponder,
    },
    /// Opens a typed SPI endpoint bound to this session.
    OpenSpi {
        resource: u32,
        endpoint: fidl::endpoints::ServerEnd<SpiEndpointMarker>,
        responder: SessionOpenSpiResponder,
    },
    /// Observes an interrupt event. Bounded hanging request that yields when
    /// the interrupt sequence exceeds `after_sequence` or upon timeout.
    WaitForInterrupt {
        resource: u32,
        after_sequence: u64,
        timeout_ns: i64,
        responder: SessionWaitForInterruptResponder,
    },
    /// One policy-checked, audited Clock enable. Requires mutation lease.
    ClockEnable { resource: u32, responder: SessionClockEnableResponder },
    /// One policy-checked, audited Clock disable. Requires mutation lease.
    ClockDisable { resource: u32, responder: SessionClockDisableResponder },
    /// One policy-checked, audited Clock is_enabled query.
    ClockIsEnabled { resource: u32, responder: SessionClockIsEnabledResponder },
    /// One policy-checked, audited Clock set_rate. Requires mutation lease.
    ClockSetRate { resource: u32, hz: u64, responder: SessionClockSetRateResponder },
    /// One policy-checked, audited Clock query_supported_rate query.
    ClockQueryRate { resource: u32, hz_in: u64, responder: SessionClockQueryRateResponder },
    /// One policy-checked, audited Clock get_rate query.
    ClockGetRate { resource: u32, responder: SessionClockGetRateResponder },
    /// One policy-checked, audited Reset assert. Requires mutation lease.
    ResetAssert { resource: u32, responder: SessionResetAssertResponder },
    /// One policy-checked, audited Reset deassert. Requires mutation lease.
    ResetDeassert { resource: u32, responder: SessionResetDeassertResponder },
    /// One policy-checked, audited Reset toggle. Requires mutation lease.
    ResetToggle { resource: u32, responder: SessionResetToggleResponder },
    /// One policy-checked, audited Reset status query.
    ResetStatus { resource: u32, responder: SessionResetStatusResponder },
    /// One policy-checked, audited Serial read.
    SerialRead { resource: u32, responder: SessionSerialReadResponder },
    /// One policy-checked, audited Serial write. Requires mutation lease.
    SerialWrite { resource: u32, data: Vec<u8>, responder: SessionSerialWriteResponder },
    /// 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: SessionControlHandle,
        method_type: fidl::MethodType,
    },
}

impl SessionRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_read32(self) -> Option<(u32, u64, SessionRead32Responder)> {
        if let SessionRequest::Read32 { resource, offset, responder } = self {
            Some((resource, offset, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_snapshot(self) -> Option<(Vec<SnapshotItem>, SessionSnapshotResponder)> {
        if let SessionRequest::Snapshot { items, responder } = self {
            Some((items, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_audit(self) -> Option<(u64, u32, SessionReadAuditResponder)> {
        if let SessionRequest::ReadAudit { cursor, limit, responder } = self {
            Some((cursor, limit, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write32(
        self,
    ) -> Option<(u32, u64, u32, u32, Option<Box<WritePrecondition>>, bool, SessionWrite32Responder)>
    {
        if let SessionRequest::Write32 {
            resource,
            offset,
            value,
            write_mask,
            precondition,
            readback,
            responder,
        } = self
        {
            Some((resource, offset, value, write_mask, precondition, readback, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_poll32(self) -> Option<(u32, u64, u32, u32, i64, i64, SessionPoll32Responder)> {
        if let SessionRequest::Poll32 {
            resource,
            offset,
            expected,
            mask,
            interval_ns,
            timeout_ns,
            responder,
        } = self
        {
            Some((resource, offset, expected, mask, interval_ns, timeout_ns, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_execute_sequence(
        self,
    ) -> Option<(Vec<SequenceItem>, SessionExecuteSequenceResponder)> {
        if let SessionRequest::ExecuteSequence { items, responder } = self {
            Some((items, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_gpio_read(self) -> Option<(u32, SessionGpioReadResponder)> {
        if let SessionRequest::GpioRead { resource, responder } = self {
            Some((resource, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_gpio_write(self) -> Option<(u32, bool, SessionGpioWriteResponder)> {
        if let SessionRequest::GpioWrite { resource, value, responder } = self {
            Some((resource, value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_i2c_transfer(self) -> Option<(u32, Vec<u8>, u32, SessionI2cTransferResponder)> {
        if let SessionRequest::I2cTransfer { resource, write_data, read_length, responder } = self {
            Some((resource, write_data, read_length, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_spi_transmit(self) -> Option<(u32, Vec<u8>, SessionSpiTransmitResponder)> {
        if let SessionRequest::SpiTransmit { resource, tx_data, responder } = self {
            Some((resource, tx_data, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_gpio(
        self,
    ) -> Option<(u32, fidl::endpoints::ServerEnd<GpioEndpointMarker>, SessionOpenGpioResponder)>
    {
        if let SessionRequest::OpenGpio { resource, endpoint, responder } = self {
            Some((resource, endpoint, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_i2c(
        self,
    ) -> Option<(u32, fidl::endpoints::ServerEnd<I2cEndpointMarker>, SessionOpenI2cResponder)> {
        if let SessionRequest::OpenI2c { resource, endpoint, responder } = self {
            Some((resource, endpoint, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_open_spi(
        self,
    ) -> Option<(u32, fidl::endpoints::ServerEnd<SpiEndpointMarker>, SessionOpenSpiResponder)> {
        if let SessionRequest::OpenSpi { resource, endpoint, responder } = self {
            Some((resource, endpoint, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_wait_for_interrupt(
        self,
    ) -> Option<(u32, u64, i64, SessionWaitForInterruptResponder)> {
        if let SessionRequest::WaitForInterrupt {
            resource,
            after_sequence,
            timeout_ns,
            responder,
        } = self
        {
            Some((resource, after_sequence, timeout_ns, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clock_enable(self) -> Option<(u32, SessionClockEnableResponder)> {
        if let SessionRequest::ClockEnable { resource, responder } = self {
            Some((resource, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clock_disable(self) -> Option<(u32, SessionClockDisableResponder)> {
        if let SessionRequest::ClockDisable { resource, responder } = self {
            Some((resource, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clock_is_enabled(self) -> Option<(u32, SessionClockIsEnabledResponder)> {
        if let SessionRequest::ClockIsEnabled { resource, responder } = self {
            Some((resource, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clock_set_rate(self) -> Option<(u32, u64, SessionClockSetRateResponder)> {
        if let SessionRequest::ClockSetRate { resource, hz, responder } = self {
            Some((resource, hz, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clock_query_rate(self) -> Option<(u32, u64, SessionClockQueryRateResponder)> {
        if let SessionRequest::ClockQueryRate { resource, hz_in, responder } = self {
            Some((resource, hz_in, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clock_get_rate(self) -> Option<(u32, SessionClockGetRateResponder)> {
        if let SessionRequest::ClockGetRate { resource, responder } = self {
            Some((resource, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reset_assert(self) -> Option<(u32, SessionResetAssertResponder)> {
        if let SessionRequest::ResetAssert { resource, responder } = self {
            Some((resource, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reset_deassert(self) -> Option<(u32, SessionResetDeassertResponder)> {
        if let SessionRequest::ResetDeassert { resource, responder } = self {
            Some((resource, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reset_toggle(self) -> Option<(u32, SessionResetToggleResponder)> {
        if let SessionRequest::ResetToggle { resource, responder } = self {
            Some((resource, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reset_status(self) -> Option<(u32, SessionResetStatusResponder)> {
        if let SessionRequest::ResetStatus { resource, responder } = self {
            Some((resource, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_serial_read(self) -> Option<(u32, SessionSerialReadResponder)> {
        if let SessionRequest::SerialRead { resource, responder } = self {
            Some((resource, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_serial_write(self) -> Option<(u32, Vec<u8>, SessionSerialWriteResponder)> {
        if let SessionRequest::SerialWrite { resource, data, responder } = self {
            Some((resource, data, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            SessionRequest::Read32 { .. } => "read32",
            SessionRequest::Snapshot { .. } => "snapshot",
            SessionRequest::ReadAudit { .. } => "read_audit",
            SessionRequest::Write32 { .. } => "write32",
            SessionRequest::Poll32 { .. } => "poll32",
            SessionRequest::ExecuteSequence { .. } => "execute_sequence",
            SessionRequest::GpioRead { .. } => "gpio_read",
            SessionRequest::GpioWrite { .. } => "gpio_write",
            SessionRequest::I2cTransfer { .. } => "i2c_transfer",
            SessionRequest::SpiTransmit { .. } => "spi_transmit",
            SessionRequest::OpenGpio { .. } => "open_gpio",
            SessionRequest::OpenI2c { .. } => "open_i2c",
            SessionRequest::OpenSpi { .. } => "open_spi",
            SessionRequest::WaitForInterrupt { .. } => "wait_for_interrupt",
            SessionRequest::ClockEnable { .. } => "clock_enable",
            SessionRequest::ClockDisable { .. } => "clock_disable",
            SessionRequest::ClockIsEnabled { .. } => "clock_is_enabled",
            SessionRequest::ClockSetRate { .. } => "clock_set_rate",
            SessionRequest::ClockQueryRate { .. } => "clock_query_rate",
            SessionRequest::ClockGetRate { .. } => "clock_get_rate",
            SessionRequest::ResetAssert { .. } => "reset_assert",
            SessionRequest::ResetDeassert { .. } => "reset_deassert",
            SessionRequest::ResetToggle { .. } => "reset_toggle",
            SessionRequest::ResetStatus { .. } => "reset_status",
            SessionRequest::SerialRead { .. } => "serial_read",
            SessionRequest::SerialWrite { .. } => "serial_write",
            SessionRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            SessionRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<(u32, u64, i64), OperationError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleResultType<ReadResult, OperationError>>(
                fidl::encoding::FlexibleResult::new(result),
                self.tx_id,
                0x7afec1bfecc09a54,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut result: Result<(&[SnapshotItemResult], bool), OperationError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleResultType<SnapshotResult, OperationError>>(
                fidl::encoding::FlexibleResult::new(result),
                self.tx_id,
                0x5fa90e4c39fa72e1,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

    fn control_handle(&self) -> &SessionControlHandle {
        &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 SessionReadAuditResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut entries: &[AuditEntry],
        mut has_oldest: bool,
        mut oldest_retained: u64,
        mut next_cursor: u64,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(entries, has_oldest, oldest_retained, next_cursor);
        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 entries: &[AuditEntry],
        mut has_oldest: bool,
        mut oldest_retained: u64,
        mut next_cursor: u64,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(entries, has_oldest, oldest_retained, next_cursor);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut entries: &[AuditEntry],
        mut has_oldest: bool,
        mut oldest_retained: u64,
        mut next_cursor: u64,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<AuditPage>>(
            fidl::encoding::Flexible::new((entries, has_oldest, oldest_retained, next_cursor)),
            self.tx_id,
            0x4906c4144e00f4c4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<(u32, u64, i64), OperationError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleResultType<WriteResult, OperationError>>(
                fidl::encoding::FlexibleResult::new(result),
                self.tx_id,
                0x80dcccde698980c,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<(u32, u64, i64), OperationError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleResultType<PollResult, OperationError>>(
                fidl::encoding::FlexibleResult::new(result),
                self.tx_id,
                0x3b9c26d1582fff7d,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut result: Result<(&[SequenceItemResult], bool), OperationError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleResultType<SequenceResult, OperationError>>(
                fidl::encoding::FlexibleResult::new(result),
                self.tx_id,
                0xf0500bd7555a614,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut result: Result<(bool, u64, i64), OperationError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleResultType<GpioReadResult, OperationError>>(
                fidl::encoding::FlexibleResult::new(result),
                self.tx_id,
                0xb01fc817332de51,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<(u32, u64, u64, i64, u64), OperationError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::FlexibleResultType<InterruptResult, OperationError>>(
                fidl::encoding::FlexibleResult::new(result),
                self.tx_id,
                0x276a31c24a164cdb,
                fidl::encoding::DynamicFlags::FLEXIBLE,
            )
    }
}

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<(bool, u64, i64), OperationError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            ClockIsEnabledResult,
            OperationError,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x36a033a7a1322174,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<(bool, u64, i64), OperationError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            ResetStatusResult,
            OperationError,
        >>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x1790a96ce5f3b3d9,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for SpiEndpointMarker {
    type Proxy = SpiEndpointProxy;
    type RequestStream = SpiEndpointRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SpiEndpointSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) SpiEndpoint";
}
pub type SpiEndpointTransmitResult = Result<(Vec<u8>, u64, i64), OperationError>;

pub trait SpiEndpointProxyInterface: Send + Sync {
    type TransmitResponseFut: std::future::Future<Output = Result<SpiEndpointTransmitResult, fidl::Error>>
        + Send;
    fn r#transmit(&self, tx_data: &[u8]) -> Self::TransmitResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SpiEndpointSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SpiEndpointSynchronousProxy {
    type Proxy = SpiEndpointProxy;
    type Protocol = SpiEndpointMarker;

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

    pub fn r#transmit(
        &self,
        mut tx_data: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SpiEndpointTransmitResult, fidl::Error> {
        let _response = self.client.send_query::<
            SpiEndpointTransmitRequest,
            fidl::encoding::FlexibleResultType<SpiTransmitResult, OperationError>,
            SpiEndpointMarker,
        >(
            (tx_data,),
            0x71f374cd592ecaa3,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SpiEndpointMarker>("transmit")?;
        Ok(_response.map(|x| (x.rx_data, x.audit_seq, x.timestamp_ns)))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for SpiEndpointProxy {
    type Protocol = SpiEndpointMarker;

    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 SpiEndpointProxy {
    /// Create a new Proxy for fuchsia.driver.lab/SpiEndpoint.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <SpiEndpointMarker 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) -> SpiEndpointEventStream {
        SpiEndpointEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#transmit(
        &self,
        mut tx_data: &[u8],
    ) -> fidl::client::QueryResponseFut<
        SpiEndpointTransmitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SpiEndpointProxyInterface::r#transmit(self, tx_data)
    }
}

impl SpiEndpointProxyInterface for SpiEndpointProxy {
    type TransmitResponseFut = fidl::client::QueryResponseFut<
        SpiEndpointTransmitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#transmit(&self, mut tx_data: &[u8]) -> Self::TransmitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SpiEndpointTransmitResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<SpiTransmitResult, OperationError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x71f374cd592ecaa3,
            >(_buf?)?
            .into_result::<SpiEndpointMarker>("transmit")?;
            Ok(_response.map(|x| (x.rx_data, x.audit_seq, x.timestamp_ns)))
        }
        self.client.send_query_and_decode::<SpiEndpointTransmitRequest, SpiEndpointTransmitResult>(
            (tx_data,),
            0x71f374cd592ecaa3,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.driver.lab/SpiEndpoint.
pub struct SpiEndpointRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for SpiEndpointRequestStream {
    type Protocol = SpiEndpointMarker;
    type ControlHandle = SpiEndpointControlHandle;

    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 {
        SpiEndpointControlHandle { 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 SpiEndpointRequestStream {
    type Item = Result<SpiEndpointRequest, 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 SpiEndpointRequestStream 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 {
                    0x71f374cd592ecaa3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SpiEndpointTransmitRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SpiEndpointTransmitRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SpiEndpointControlHandle { inner: this.inner.clone() };
                        Ok(SpiEndpointRequest::Transmit {
                            tx_data: req.tx_data,

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

/// Typed endpoint for a SPI protocol resource.
#[derive(Debug)]
pub enum SpiEndpointRequest {
    Transmit {
        tx_data: Vec<u8>,
        responder: SpiEndpointTransmitResponder,
    },
    /// 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: SpiEndpointControlHandle,
        method_type: fidl::MethodType,
    },
}

impl SpiEndpointRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_transmit(self) -> Option<(Vec<u8>, SpiEndpointTransmitResponder)> {
        if let SpiEndpointRequest::Transmit { tx_data, responder } = self {
            Some((tx_data, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

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

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

#[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.driver.lab.Service";
}

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

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

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

    fn member_names() -> &'static [&'static str] {
        &["proxy"]
    }
}
#[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_proxy(&self) -> Result<Proxy_Proxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<Proxy_Marker>();
        self.connect_channel_to_proxy(server_end)?;
        Ok(proxy)
    }

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

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

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

mod internal {
    use super::*;

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            ProxyOpenSessionRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ProxyOpenSessionRequest
    {
        #[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::<ProxyOpenSessionRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ProxyOpenSessionRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <RunContext as fidl::encoding::ValueTypeMarker>::borrow(&self.context),
                    <SessionMode as fidl::encoding::ValueTypeMarker>::borrow(&self.mode),
                    <Expectations as fidl::encoding::ValueTypeMarker>::borrow(&self.expectations),
                    <fidl::encoding::Vector<AccessRule, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.allowlist),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.session),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<RunContext, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<SessionMode, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<Expectations, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T3: fidl::encoding::Encode<
                fidl::encoding::Vector<AccessRule, 256>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T4: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ProxyOpenSessionRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3, T4)
    {
        #[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::<ProxyOpenSessionRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(56);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            self.3.encode(encoder, offset + 40, depth)?;
            self.4.encode(encoder, offset + 56, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ProxyOpenSessionRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                context: fidl::new_empty!(
                    RunContext,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                mode: fidl::new_empty!(SessionMode, fidl::encoding::DefaultFuchsiaResourceDialect),
                expectations: fidl::new_empty!(
                    Expectations,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                allowlist: fidl::new_empty!(fidl::encoding::Vector<AccessRule, 256>, fidl::encoding::DefaultFuchsiaResourceDialect),
                session: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(56) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 56 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                RunContext,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.context,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                SessionMode,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.mode,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                Expectations,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.expectations,
                decoder,
                offset + 24,
                _depth
            )?;
            fidl::decode!(fidl::encoding::Vector<AccessRule, 256>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.allowlist, decoder, offset + 40, _depth)?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SessionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.session,
                decoder,
                offset + 56,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            SessionOpenGpioRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut SessionOpenGpioRequest
    {
        #[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::<SessionOpenGpioRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SessionOpenGpioRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.resource),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<GpioEndpointMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.endpoint),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<GpioEndpointMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            SessionOpenGpioRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SessionOpenGpioRequest>(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)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for SessionOpenGpioRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                resource: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                endpoint: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<GpioEndpointMarker>>,
                    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!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.resource,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<GpioEndpointMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.endpoint,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<SessionOpenI2cRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut SessionOpenI2cRequest
    {
        #[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::<SessionOpenI2cRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SessionOpenI2cRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.resource),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<I2cEndpointMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.endpoint),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<I2cEndpointMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<SessionOpenI2cRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SessionOpenI2cRequest>(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)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for SessionOpenI2cRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                resource: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                endpoint: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<I2cEndpointMarker>>,
                    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!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.resource,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<I2cEndpointMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.endpoint,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<SessionOpenSpiRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut SessionOpenSpiRequest
    {
        #[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::<SessionOpenSpiRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SessionOpenSpiRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.resource),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SpiEndpointMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.endpoint),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SpiEndpointMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<SessionOpenSpiRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SessionOpenSpiRequest>(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)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for SessionOpenSpiRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                resource: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                endpoint: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SpiEndpointMarker>>,
                    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!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.resource,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<SpiEndpointMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.endpoint,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }
}