fidl_fuchsia_lowpan_spinel/

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

pub const MAX_FRAME_SIZE: u32 = 4096;

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(i32)]
pub enum Error {
    /// An unspecified error has occurred. This error type should be
    /// avoided unless the use of a more specific error would be misleading.
    ///
    /// If this error is emitted, it is expected that a more descriptive error
    /// will be present in the logs.
    ///
    /// Run-time Remediation: Close and re-open the device and attempt to use it.
    /// If the error persists, indicate trouble to a higher level and stop.
    Unspecified = 1,
    /// `SendFrame()` was called with a frame that was larger than what
    /// `GetMaxFrameSize()` indicated to be the maximum frame size.
    ///
    /// Note that `MAX_FRAME_SIZE` indicates the largest frame size supported
    /// by this protocol, whereas `GetMaxFrameSize()` returns the largest
    /// frame size supported by the Device.
    ///
    /// This error typically indicates a bug or logic-error in the use of the
    /// `fuchsia.lowpan.spinel::Device` protocol.
    ///
    /// This error is only emitted via `->OnError()`.
    OutboundFrameTooLarge = 2,
    /// The remote device tried to send us a frame that was too large.
    ///
    /// This error typically indicates either frame corruption or a
    /// misconfiguration of some sort.
    ///
    /// Run-time Remediation: The device should be reset and re-initialized.
    ///
    /// This error is only emitted via `->OnError()`.
    InboundFrameTooLarge = 3,
    /// Garbage-bytes/corruption detected on inbound frame.
    ///
    /// This error typically indicates that the connection between
    /// the host and the Spinel device is unreliable. This may be caused
    /// by hardware problems or implementation bugs.
    ///
    /// Run-time Remediation: The device should be reset (by sending a
    /// spinel reset frame or by closing and re-opening) and then
    /// re-initialized.
    ///
    /// This error is only emitted via `->OnError()`.
    InboundFrameCorrupt = 4,
    /// An I/O error has occurred.
    ///
    /// When this error is encountered, the device automatically closes.
    ///
    /// Run-time Remediation: Re-open the device and attempt to use it. If
    /// the error persists, indicate trouble to a higher level (for example,
    /// presenting a UI message indicating a malfunction) and stop.
    IoError = 5,
    /// This operation cannot be performed while the Spinel device is closed.
    ///
    /// This error typically indicates a bug or logic-error in the use of the
    /// `fuchsia.lowpan.spinel::Device` protocol.
    ///
    /// This error is only emitted via `->OnError()`.
    Closed = 6,
}

impl Error {
    #[inline]
    pub fn from_primitive(prim: i32) -> Option<Self> {
        match prim {
            1 => Some(Self::Unspecified),
            2 => Some(Self::OutboundFrameTooLarge),
            3 => Some(Self::InboundFrameTooLarge),
            4 => Some(Self::InboundFrameCorrupt),
            5 => Some(Self::IoError),
            6 => Some(Self::Closed),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> i32 {
        self as i32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DeviceGetMaxFrameSizeResponse {
    pub size: u32,
}

impl fidl::Persistable for DeviceGetMaxFrameSizeResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceOnErrorRequest {
    pub error: Error,
    pub did_close: bool,
}

impl fidl::Persistable for DeviceOnErrorRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DeviceOnReadyForSendFramesRequest {
    pub number_of_frames: u32,
}

impl fidl::Persistable for DeviceOnReadyForSendFramesRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceOnReceiveFrameRequest {
    pub data: Vec<u8>,
}

impl fidl::Persistable for DeviceOnReceiveFrameRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DeviceReadyToReceiveFramesRequest {
    pub number_of_frames: u32,
}

impl fidl::Persistable for DeviceReadyToReceiveFramesRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceSendFrameRequest {
    pub data: Vec<u8>,
}

impl fidl::Persistable for DeviceSendFrameRequest {}

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

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

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

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

    const DEBUG_NAME: &'static str = "fuchsia.lowpan.spinel.Device";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DeviceMarker {}
pub type DeviceOpenResult = Result<(), Error>;
pub type DeviceCloseResult = Result<(), Error>;

pub trait DeviceProxyInterface: Send + Sync {
    type OpenResponseFut: std::future::Future<Output = Result<DeviceOpenResult, fidl::Error>> + Send;
    fn r#open(&self) -> Self::OpenResponseFut;
    type CloseResponseFut: std::future::Future<Output = Result<DeviceCloseResult, fidl::Error>>
        + Send;
    fn r#close(&self) -> Self::CloseResponseFut;
    type GetMaxFrameSizeResponseFut: std::future::Future<Output = Result<u32, fidl::Error>> + Send;
    fn r#get_max_frame_size(&self) -> Self::GetMaxFrameSizeResponseFut;
    fn r#send_frame(&self, data: &[u8]) -> Result<(), fidl::Error>;
    fn r#ready_to_receive_frames(&self, number_of_frames: u32) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DeviceSynchronousProxy {
    client: fidl::client::sync::Client,
}

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

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl DeviceSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    /// Opens the Spinel connection and performs initialization.
    ///
    /// This method will block until the Device is ready to use or
    /// an error has been encountered. If an error is indicated,
    /// the device is still considered closed.
    ///
    /// Calling this method will typically induce reset if
    /// supported by the underlying hardware. It may be called
    /// while the device is already open in order to trigger a
    /// reset.
    ///
    /// Possible error codes:
    ///
    /// * `Error::IO_ERROR`: An IO error occurred.
    /// * `Error::UNSPECIFIED`: An unspecified error occurred.
    ///                         See logs for more details.
    pub fn r#open(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceOpenResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (),
            0x508cecb73a776ef7,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Close the Spinel connection.
    ///
    /// This method will block until the Device has successfully
    /// been put into a closed (preferably low-power) state. An
    /// error may be indicated if a problem was encountered that
    /// may indicate the device did not close cleanly.
    ///
    /// Calling this method will always cause this interface to be
    /// closed, even if an error is reported. Thus, the error may
    /// be simply ignored or logged.
    ///
    /// Calling this method when the device is already closed
    /// will do nothing.
    ///
    /// Possible error codes:
    ///
    /// * `Error::IO_ERROR`: An IO error occurred.
    /// * `Error::UNSPECIFIED`: An unspecified error occurred.
    ///                         See logs for more details.
    pub fn r#close(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceCloseResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (),
            0x621a0f31b867781a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Fetch the max frame size.
    ///
    /// This method may be called at any time. The returned
    /// value is an implementation-specific constant.
    ///
    /// @return The size of the largest frame that this implementation
    /// supports being passed into `SendFrame()`.
    pub fn r#get_max_frame_size(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<u32, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, DeviceGetMaxFrameSizeResponse>(
                (),
                0x1d2d652e8b06d463,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.size)
    }

    /// Sends a Spinel-formatted frame to the device.
    ///
    /// Calling this method while the device is closed will cause
    /// the frame to be dropped and `->OnError()` to emit `Error::CLOSED`.
    ///
    /// See `->OnReadyForSendFrames()` for flow-control considerations.
    pub fn r#send_frame(&self, mut data: &[u8]) -> Result<(), fidl::Error> {
        self.client.send::<DeviceSendFrameRequest>(
            (data,),
            0x634f2957b35c5944,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Increases the number of additional frames that the caller is
    /// currently ready to receive, as a method of inbound flow-control.
    ///
    /// The caller can use this method to regulate the speed at which
    /// inbound frames are handled. This method should be called periodically
    /// to ensure low-latency frame delivery.
    ///
    /// Calling this method with a non-zero value indicates to the
    /// receiver that the caller is ready to receive the specified
    /// additional number of frames.
    ///
    /// This method SHOULD NOT be called with a value of zero. If the
    /// receiver gets this call with a value of zero, it MUST be ignored.
    ///
    /// Frames will not be received until this method is first called
    /// with a non-zero value. Once received, the receiver will limit
    /// the number of subsequent frames emitted via `->OnReceiveFrame()`
    /// to the given number of frames.
    ///
    /// Calling this method while the device is closed will do nothing.
    ///
    /// A reasonable usage pattern would be to first call this method
    /// with a value of 4, calling it again with a value of 2 after
    /// every second received inbound frame.
    ///
    /// Outbound flow control is similarly accomplished via `->OnReadyForSendFrames()`.
    pub fn r#ready_to_receive_frames(&self, mut number_of_frames: u32) -> Result<(), fidl::Error> {
        self.client.send::<DeviceReadyToReceiveFramesRequest>(
            (number_of_frames,),
            0x3147df23fdd53b87,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl DeviceProxy {
    /// Create a new Proxy for fuchsia.lowpan.spinel/Device.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DeviceEventStream {
        DeviceEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Opens the Spinel connection and performs initialization.
    ///
    /// This method will block until the Device is ready to use or
    /// an error has been encountered. If an error is indicated,
    /// the device is still considered closed.
    ///
    /// Calling this method will typically induce reset if
    /// supported by the underlying hardware. It may be called
    /// while the device is already open in order to trigger a
    /// reset.
    ///
    /// Possible error codes:
    ///
    /// * `Error::IO_ERROR`: An IO error occurred.
    /// * `Error::UNSPECIFIED`: An unspecified error occurred.
    ///                         See logs for more details.
    pub fn r#open(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DeviceOpenResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#open(self)
    }

    /// Close the Spinel connection.
    ///
    /// This method will block until the Device has successfully
    /// been put into a closed (preferably low-power) state. An
    /// error may be indicated if a problem was encountered that
    /// may indicate the device did not close cleanly.
    ///
    /// Calling this method will always cause this interface to be
    /// closed, even if an error is reported. Thus, the error may
    /// be simply ignored or logged.
    ///
    /// Calling this method when the device is already closed
    /// will do nothing.
    ///
    /// Possible error codes:
    ///
    /// * `Error::IO_ERROR`: An IO error occurred.
    /// * `Error::UNSPECIFIED`: An unspecified error occurred.
    ///                         See logs for more details.
    pub fn r#close(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DeviceCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#close(self)
    }

    /// Fetch the max frame size.
    ///
    /// This method may be called at any time. The returned
    /// value is an implementation-specific constant.
    ///
    /// @return The size of the largest frame that this implementation
    /// supports being passed into `SendFrame()`.
    pub fn r#get_max_frame_size(
        &self,
    ) -> fidl::client::QueryResponseFut<u32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DeviceProxyInterface::r#get_max_frame_size(self)
    }

    /// Sends a Spinel-formatted frame to the device.
    ///
    /// Calling this method while the device is closed will cause
    /// the frame to be dropped and `->OnError()` to emit `Error::CLOSED`.
    ///
    /// See `->OnReadyForSendFrames()` for flow-control considerations.
    pub fn r#send_frame(&self, mut data: &[u8]) -> Result<(), fidl::Error> {
        DeviceProxyInterface::r#send_frame(self, data)
    }

    /// Increases the number of additional frames that the caller is
    /// currently ready to receive, as a method of inbound flow-control.
    ///
    /// The caller can use this method to regulate the speed at which
    /// inbound frames are handled. This method should be called periodically
    /// to ensure low-latency frame delivery.
    ///
    /// Calling this method with a non-zero value indicates to the
    /// receiver that the caller is ready to receive the specified
    /// additional number of frames.
    ///
    /// This method SHOULD NOT be called with a value of zero. If the
    /// receiver gets this call with a value of zero, it MUST be ignored.
    ///
    /// Frames will not be received until this method is first called
    /// with a non-zero value. Once received, the receiver will limit
    /// the number of subsequent frames emitted via `->OnReceiveFrame()`
    /// to the given number of frames.
    ///
    /// Calling this method while the device is closed will do nothing.
    ///
    /// A reasonable usage pattern would be to first call this method
    /// with a value of 4, calling it again with a value of 2 after
    /// every second received inbound frame.
    ///
    /// Outbound flow control is similarly accomplished via `->OnReadyForSendFrames()`.
    pub fn r#ready_to_receive_frames(&self, mut number_of_frames: u32) -> Result<(), fidl::Error> {
        DeviceProxyInterface::r#ready_to_receive_frames(self, number_of_frames)
    }
}

impl DeviceProxyInterface for DeviceProxy {
    type OpenResponseFut = fidl::client::QueryResponseFut<
        DeviceOpenResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#open(&self) -> Self::OpenResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceOpenResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x508cecb73a776ef7,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, DeviceOpenResult>(
            (),
            0x508cecb73a776ef7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type GetMaxFrameSizeResponseFut =
        fidl::client::QueryResponseFut<u32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_max_frame_size(&self) -> Self::GetMaxFrameSizeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceGetMaxFrameSizeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1d2d652e8b06d463,
            >(_buf?)?;
            Ok(_response.size)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u32>(
            (),
            0x1d2d652e8b06d463,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#send_frame(&self, mut data: &[u8]) -> Result<(), fidl::Error> {
        self.client.send::<DeviceSendFrameRequest>(
            (data,),
            0x634f2957b35c5944,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#ready_to_receive_frames(&self, mut number_of_frames: u32) -> Result<(), fidl::Error> {
        self.client.send::<DeviceReadyToReceiveFramesRequest>(
            (number_of_frames,),
            0x3147df23fdd53b87,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

impl futures::Stream for DeviceEventStream {
    type Item = Result<DeviceEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(DeviceEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum DeviceEvent {
    OnReadyForSendFrames { number_of_frames: u32 },
    OnReceiveFrame { data: Vec<u8> },
    OnError { error: Error, did_close: bool },
}

impl DeviceEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_ready_for_send_frames(self) -> Option<u32> {
        if let DeviceEvent::OnReadyForSendFrames { number_of_frames } = self {
            Some((number_of_frames))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_receive_frame(self) -> Option<Vec<u8>> {
        if let DeviceEvent::OnReceiveFrame { data } = self {
            Some((data))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_error(self) -> Option<(Error, bool)> {
        if let DeviceEvent::OnError { error, did_close } = self {
            Some((error, did_close))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`DeviceEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<DeviceEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            0x2b1d5b28c5811b53 => {
                let mut out = fidl::new_empty!(
                    DeviceOnReadyForSendFramesRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceOnReadyForSendFramesRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((DeviceEvent::OnReadyForSendFrames { number_of_frames: out.number_of_frames }))
            }
            0x61937a45670aabb0 => {
                let mut out = fidl::new_empty!(
                    DeviceOnReceiveFrameRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceOnReceiveFrameRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((DeviceEvent::OnReceiveFrame { data: out.data }))
            }
            0x4d20e65a9d2625e1 => {
                let mut out = fidl::new_empty!(
                    DeviceOnErrorRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceOnErrorRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((DeviceEvent::OnError { error: out.error, did_close: out.did_close }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

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

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        DeviceControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for DeviceRequestStream {
    type Item = Result<DeviceRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled DeviceRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x508cecb73a776ef7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::Open {
                            responder: DeviceOpenResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x621a0f31b867781a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::Close {
                            responder: DeviceCloseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1d2d652e8b06d463 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetMaxFrameSize {
                            responder: DeviceGetMaxFrameSizeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x634f2957b35c5944 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceSendFrameRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceSendFrameRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::SendFrame { data: req.data, control_handle })
                    }
                    0x3147df23fdd53b87 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceReadyToReceiveFramesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceReadyToReceiveFramesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::ReadyToReceiveFrames {
                            number_of_frames: req.number_of_frames,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum DeviceRequest {
    /// Opens the Spinel connection and performs initialization.
    ///
    /// This method will block until the Device is ready to use or
    /// an error has been encountered. If an error is indicated,
    /// the device is still considered closed.
    ///
    /// Calling this method will typically induce reset if
    /// supported by the underlying hardware. It may be called
    /// while the device is already open in order to trigger a
    /// reset.
    ///
    /// Possible error codes:
    ///
    /// * `Error::IO_ERROR`: An IO error occurred.
    /// * `Error::UNSPECIFIED`: An unspecified error occurred.
    ///                         See logs for more details.
    Open { responder: DeviceOpenResponder },
    /// Close the Spinel connection.
    ///
    /// This method will block until the Device has successfully
    /// been put into a closed (preferably low-power) state. An
    /// error may be indicated if a problem was encountered that
    /// may indicate the device did not close cleanly.
    ///
    /// Calling this method will always cause this interface to be
    /// closed, even if an error is reported. Thus, the error may
    /// be simply ignored or logged.
    ///
    /// Calling this method when the device is already closed
    /// will do nothing.
    ///
    /// Possible error codes:
    ///
    /// * `Error::IO_ERROR`: An IO error occurred.
    /// * `Error::UNSPECIFIED`: An unspecified error occurred.
    ///                         See logs for more details.
    Close { responder: DeviceCloseResponder },
    /// Fetch the max frame size.
    ///
    /// This method may be called at any time. The returned
    /// value is an implementation-specific constant.
    ///
    /// @return The size of the largest frame that this implementation
    /// supports being passed into `SendFrame()`.
    GetMaxFrameSize { responder: DeviceGetMaxFrameSizeResponder },
    /// Sends a Spinel-formatted frame to the device.
    ///
    /// Calling this method while the device is closed will cause
    /// the frame to be dropped and `->OnError()` to emit `Error::CLOSED`.
    ///
    /// See `->OnReadyForSendFrames()` for flow-control considerations.
    SendFrame { data: Vec<u8>, control_handle: DeviceControlHandle },
    /// Increases the number of additional frames that the caller is
    /// currently ready to receive, as a method of inbound flow-control.
    ///
    /// The caller can use this method to regulate the speed at which
    /// inbound frames are handled. This method should be called periodically
    /// to ensure low-latency frame delivery.
    ///
    /// Calling this method with a non-zero value indicates to the
    /// receiver that the caller is ready to receive the specified
    /// additional number of frames.
    ///
    /// This method SHOULD NOT be called with a value of zero. If the
    /// receiver gets this call with a value of zero, it MUST be ignored.
    ///
    /// Frames will not be received until this method is first called
    /// with a non-zero value. Once received, the receiver will limit
    /// the number of subsequent frames emitted via `->OnReceiveFrame()`
    /// to the given number of frames.
    ///
    /// Calling this method while the device is closed will do nothing.
    ///
    /// A reasonable usage pattern would be to first call this method
    /// with a value of 4, calling it again with a value of 2 after
    /// every second received inbound frame.
    ///
    /// Outbound flow control is similarly accomplished via `->OnReadyForSendFrames()`.
    ReadyToReceiveFrames { number_of_frames: u32, control_handle: DeviceControlHandle },
}

impl DeviceRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_open(self) -> Option<(DeviceOpenResponder)> {
        if let DeviceRequest::Open { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_send_frame(self) -> Option<(Vec<u8>, DeviceControlHandle)> {
        if let DeviceRequest::SendFrame { data, control_handle } = self {
            Some((data, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_ready_to_receive_frames(self) -> Option<(u32, DeviceControlHandle)> {
        if let DeviceRequest::ReadyToReceiveFrames { number_of_frames, control_handle } = self {
            Some((number_of_frames, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DeviceRequest::Open { .. } => "open",
            DeviceRequest::Close { .. } => "close",
            DeviceRequest::GetMaxFrameSize { .. } => "get_max_frame_size",
            DeviceRequest::SendFrame { .. } => "send_frame",
            DeviceRequest::ReadyToReceiveFrames { .. } => "ready_to_receive_frames",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for DeviceControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl DeviceControlHandle {
    pub fn send_on_ready_for_send_frames(
        &self,
        mut number_of_frames: u32,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<DeviceOnReadyForSendFramesRequest>(
            (number_of_frames,),
            0,
            0x2b1d5b28c5811b53,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_receive_frame(&self, mut data: &[u8]) -> Result<(), fidl::Error> {
        self.inner.send::<DeviceOnReceiveFrameRequest>(
            (data,),
            0,
            0x61937a45670aabb0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_error(&self, mut error: Error, mut did_close: bool) -> Result<(), fidl::Error> {
        self.inner.send::<DeviceOnErrorRequest>(
            (error, did_close),
            0,
            0x4d20e65a9d2625e1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

/// Set the the channel to be shutdown (see [`DeviceControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DeviceOpenResponder {
    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 DeviceOpenResponder {
    type ControlHandle = DeviceControlHandle;

    fn control_handle(&self) -> &DeviceControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DeviceOpenResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

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

/// Set the the channel to be shutdown (see [`DeviceControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DeviceCloseResponder {
    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 DeviceCloseResponder {
    type ControlHandle = DeviceControlHandle;

    fn control_handle(&self) -> &DeviceControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DeviceCloseResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), Error>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

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

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

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

/// Set the the channel to be shutdown (see [`DeviceControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DeviceGetMaxFrameSizeResponder {
    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 DeviceGetMaxFrameSizeResponder {
    type ControlHandle = DeviceControlHandle;

    fn control_handle(&self) -> &DeviceControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

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

    fn send_raw(&self, mut size: u32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceGetMaxFrameSizeResponse>(
            (size,),
            self.tx_id,
            0x1d2d652e8b06d463,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for DeviceSetupMarker {
    type Proxy = DeviceSetupProxy;
    type RequestStream = DeviceSetupRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DeviceSetupSynchronousProxy;

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

pub trait DeviceSetupProxyInterface: Send + Sync {
    type SetChannelResponseFut: std::future::Future<Output = Result<DeviceSetupSetChannelResult, fidl::Error>>
        + Send;
    fn r#set_channel(
        &self,
        req: fidl::endpoints::ServerEnd<DeviceMarker>,
    ) -> Self::SetChannelResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DeviceSetupSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DeviceSetupSynchronousProxy {
    type Proxy = DeviceSetupProxy;
    type Protocol = DeviceSetupMarker;

    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 DeviceSetupSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DeviceSetupMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    pub fn r#set_channel(
        &self,
        mut req: fidl::endpoints::ServerEnd<DeviceMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DeviceSetupSetChannelResult, fidl::Error> {
        let _response = self.client.send_query::<
            DeviceSetupSetChannelRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (req,),
            0x7f8e02c174ef02a5,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

impl fidl::endpoints::Proxy for DeviceSetupProxy {
    type Protocol = DeviceSetupMarker;

    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 DeviceSetupProxy {
    /// Create a new Proxy for fuchsia.lowpan.spinel/DeviceSetup.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DeviceSetupMarker 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) -> DeviceSetupEventStream {
        DeviceSetupEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#set_channel(
        &self,
        mut req: fidl::endpoints::ServerEnd<DeviceMarker>,
    ) -> fidl::client::QueryResponseFut<
        DeviceSetupSetChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceSetupProxyInterface::r#set_channel(self, req)
    }
}

impl DeviceSetupProxyInterface for DeviceSetupProxy {
    type SetChannelResponseFut = fidl::client::QueryResponseFut<
        DeviceSetupSetChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_channel(
        &self,
        mut req: fidl::endpoints::ServerEnd<DeviceMarker>,
    ) -> Self::SetChannelResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DeviceSetupSetChannelResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7f8e02c174ef02a5,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<DeviceSetupSetChannelRequest, DeviceSetupSetChannelResult>(
                (req,),
                0x7f8e02c174ef02a5,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.lowpan.spinel/DeviceSetup.
pub struct DeviceSetupRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for DeviceSetupRequestStream {
    type Protocol = DeviceSetupMarker;
    type ControlHandle = DeviceSetupControlHandle;

    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 {
        DeviceSetupControlHandle { 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 DeviceSetupRequestStream {
    type Item = Result<DeviceSetupRequest, 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 DeviceSetupRequestStream 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 {
                    0x7f8e02c174ef02a5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceSetupSetChannelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceSetupSetChannelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceSetupControlHandle { inner: this.inner.clone() };
                        Ok(DeviceSetupRequest::SetChannel {
                            req: req.req,

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

#[derive(Debug)]
pub enum DeviceSetupRequest {
    SetChannel {
        req: fidl::endpoints::ServerEnd<DeviceMarker>,
        responder: DeviceSetupSetChannelResponder,
    },
}

impl DeviceSetupRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set_channel(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<DeviceMarker>, DeviceSetupSetChannelResponder)> {
        if let DeviceSetupRequest::SetChannel { req, responder } = self {
            Some((req, responder))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for DeviceSetupControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl DeviceSetupControlHandle {}

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

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

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

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

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

mod internal {
    use super::*;
    unsafe impl fidl::encoding::TypeMarker for Error {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<i32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<i32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for Error {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Unspecified
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<i32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for DeviceGetMaxFrameSizeResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DeviceGetMaxFrameSizeResponse {
        type Owned = Self;

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<DeviceGetMaxFrameSizeResponse, D>
        for &DeviceGetMaxFrameSizeResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceGetMaxFrameSizeResponse>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut DeviceGetMaxFrameSizeResponse)
                    .write_unaligned((self as *const DeviceGetMaxFrameSizeResponse).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
        fidl::encoding::Encode<DeviceGetMaxFrameSizeResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceGetMaxFrameSizeResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for DeviceGetMaxFrameSizeResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { size: fidl::new_empty!(u32, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for DeviceOnErrorRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DeviceOnErrorRequest {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceOnErrorRequest, D>
        for &DeviceOnErrorRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceOnErrorRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceOnErrorRequest, D>::encode(
                (
                    <Error as fidl::encoding::ValueTypeMarker>::borrow(&self.error),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.did_close),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<Error, D>,
            T1: fidl::encoding::Encode<bool, D>,
        > fidl::encoding::Encode<DeviceOnErrorRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceOnErrorRequest>(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(4);
                (ptr as *mut u32).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceOnErrorRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { error: fidl::new_empty!(Error, D), did_close: fidl::new_empty!(bool, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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(4) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let mask = 0xffffff00u32;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(Error, D, &mut self.error, decoder, offset + 0, _depth)?;
            fidl::decode!(bool, D, &mut self.did_close, decoder, offset + 4, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for DeviceOnReadyForSendFramesRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DeviceOnReadyForSendFramesRequest {
        type Owned = Self;

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<DeviceOnReadyForSendFramesRequest, D>
        for &DeviceOnReadyForSendFramesRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceOnReadyForSendFramesRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut DeviceOnReadyForSendFramesRequest)
                    .write_unaligned((self as *const DeviceOnReadyForSendFramesRequest).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
        fidl::encoding::Encode<DeviceOnReadyForSendFramesRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceOnReadyForSendFramesRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for DeviceOnReadyForSendFramesRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { number_of_frames: fidl::new_empty!(u32, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for DeviceOnReceiveFrameRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DeviceOnReceiveFrameRequest {
        type Owned = Self;

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<DeviceOnReceiveFrameRequest, D> for &DeviceOnReceiveFrameRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceOnReceiveFrameRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceOnReceiveFrameRequest, D>::encode(
                (<fidl::encoding::Vector<u8, 4096> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.data,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 4096>, D>,
        > fidl::encoding::Encode<DeviceOnReceiveFrameRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceOnReceiveFrameRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for DeviceOnReceiveFrameRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { data: fidl::new_empty!(fidl::encoding::Vector<u8, 4096>, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for DeviceReadyToReceiveFramesRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DeviceReadyToReceiveFramesRequest {
        type Owned = Self;

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<DeviceReadyToReceiveFramesRequest, D>
        for &DeviceReadyToReceiveFramesRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceReadyToReceiveFramesRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut DeviceReadyToReceiveFramesRequest)
                    .write_unaligned((self as *const DeviceReadyToReceiveFramesRequest).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
        fidl::encoding::Encode<DeviceReadyToReceiveFramesRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceReadyToReceiveFramesRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for DeviceReadyToReceiveFramesRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { number_of_frames: fidl::new_empty!(u32, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for DeviceSendFrameRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DeviceSendFrameRequest {
        type Owned = Self;

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<DeviceSendFrameRequest, D> for &DeviceSendFrameRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceSendFrameRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceSendFrameRequest, D>::encode(
                (<fidl::encoding::Vector<u8, 4096> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.data,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 4096>, D>,
        > fidl::encoding::Encode<DeviceSendFrameRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceSendFrameRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for DeviceSendFrameRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { data: fidl::new_empty!(fidl::encoding::Vector<u8, 4096>, D) }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            DeviceSetupSetChannelRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DeviceSetupSetChannelRequest
    {
        #[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::<DeviceSetupSetChannelRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceSetupSetChannelRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.req),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DeviceSetupSetChannelRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DeviceSetupSetChannelRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DeviceSetupSetChannelRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                req: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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