fidl_fuchsia_lowpan_thread/

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CapabilitiesConnectorConnectRequest {
    pub name: String,
    pub server_end: fidl::endpoints::ServerEnd<ThreadCapabilitiesMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DatasetConnectorConnectRequest {
    pub name: String,
    pub server_end: fidl::endpoints::ServerEnd<DatasetMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct EpskcConnectorConnectRequest {
    pub name: String,
    pub server_end: fidl::endpoints::ServerEnd<EpskcMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FeatureConnectorConnectRequest {
    pub name: String,
    pub server_end: fidl::endpoints::ServerEnd<FeatureMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MeshcopConnectorConnectRequest {
    pub name: String,
    pub server_end: fidl::endpoints::ServerEnd<MeshcopMarker>,
}

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

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

impl fidl::endpoints::ProtocolMarker for CapabilitiesConnectorMarker {
    type Proxy = CapabilitiesConnectorProxy;
    type RequestStream = CapabilitiesConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CapabilitiesConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.lowpan.thread.CapabilitiesConnector";
}
impl fidl::endpoints::DiscoverableProtocolMarker for CapabilitiesConnectorMarker {}

pub trait CapabilitiesConnectorProxyInterface: Send + Sync {
    fn r#connect(
        &self,
        name: &str,
        server_end: fidl::endpoints::ServerEnd<ThreadCapabilitiesMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CapabilitiesConnectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CapabilitiesConnectorSynchronousProxy {
    type Proxy = CapabilitiesConnectorProxy;
    type Protocol = CapabilitiesConnectorMarker;

    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 CapabilitiesConnectorSynchronousProxy {
    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<CapabilitiesConnectorEvent, fidl::Error> {
        CapabilitiesConnectorEvent::decode(
            self.client.wait_for_event::<CapabilitiesConnectorMarker>(deadline)?,
        )
    }

    /// Connects to the [`ThreadCapabilities`] protocol on the
    /// named LoWPAN device.
    ///
    /// The name of the interface can be learned by calling
    /// [`fuchsia.lowpan/Lookup.GetDevices`].
    ///
    /// If there is an error in processing this request
    /// the given channel is closed and an epitaph code used
    /// to describe the reason for the failure:
    ///
    /// * `ZX_ERR_INVALID_ARGUMENT`: The given interface name
    ///   was not formatted correctly or otherwise invalid.
    /// * `ZX_ERR_NOT_FOUND`: No interface was found with the
    ///   given name.
    /// * `ZX_ERR_NOT_SUPPORTED`: The interface exists but
    ///   does not support this protocol.
    pub fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<ThreadCapabilitiesMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<CapabilitiesConnectorConnectRequest>(
            (name, server_end),
            0x1dadd551ecacd85,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for CapabilitiesConnectorProxy {
    type Protocol = CapabilitiesConnectorMarker;

    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 CapabilitiesConnectorProxy {
    /// Create a new Proxy for fuchsia.lowpan.thread/CapabilitiesConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <CapabilitiesConnectorMarker 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) -> CapabilitiesConnectorEventStream {
        CapabilitiesConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connects to the [`ThreadCapabilities`] protocol on the
    /// named LoWPAN device.
    ///
    /// The name of the interface can be learned by calling
    /// [`fuchsia.lowpan/Lookup.GetDevices`].
    ///
    /// If there is an error in processing this request
    /// the given channel is closed and an epitaph code used
    /// to describe the reason for the failure:
    ///
    /// * `ZX_ERR_INVALID_ARGUMENT`: The given interface name
    ///   was not formatted correctly or otherwise invalid.
    /// * `ZX_ERR_NOT_FOUND`: No interface was found with the
    ///   given name.
    /// * `ZX_ERR_NOT_SUPPORTED`: The interface exists but
    ///   does not support this protocol.
    pub fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<ThreadCapabilitiesMarker>,
    ) -> Result<(), fidl::Error> {
        CapabilitiesConnectorProxyInterface::r#connect(self, name, server_end)
    }
}

impl CapabilitiesConnectorProxyInterface for CapabilitiesConnectorProxy {
    fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<ThreadCapabilitiesMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<CapabilitiesConnectorConnectRequest>(
            (name, server_end),
            0x1dadd551ecacd85,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for CapabilitiesConnectorRequestStream {
    type Protocol = CapabilitiesConnectorMarker;
    type ControlHandle = CapabilitiesConnectorControlHandle;

    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 {
        CapabilitiesConnectorControlHandle { 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 CapabilitiesConnectorRequestStream {
    type Item = Result<CapabilitiesConnectorRequest, 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 CapabilitiesConnectorRequestStream 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 {
                0x1dadd551ecacd85 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(CapabilitiesConnectorConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CapabilitiesConnectorConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = CapabilitiesConnectorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(CapabilitiesConnectorRequest::Connect {name: req.name,
server_end: req.server_end,

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

/// Protocol for connecting to [`Capabilities`] on a LoWPAN device.
#[derive(Debug)]
pub enum CapabilitiesConnectorRequest {
    /// Connects to the [`ThreadCapabilities`] protocol on the
    /// named LoWPAN device.
    ///
    /// The name of the interface can be learned by calling
    /// [`fuchsia.lowpan/Lookup.GetDevices`].
    ///
    /// If there is an error in processing this request
    /// the given channel is closed and an epitaph code used
    /// to describe the reason for the failure:
    ///
    /// * `ZX_ERR_INVALID_ARGUMENT`: The given interface name
    ///   was not formatted correctly or otherwise invalid.
    /// * `ZX_ERR_NOT_FOUND`: No interface was found with the
    ///   given name.
    /// * `ZX_ERR_NOT_SUPPORTED`: The interface exists but
    ///   does not support this protocol.
    Connect {
        name: String,
        server_end: fidl::endpoints::ServerEnd<ThreadCapabilitiesMarker>,
        control_handle: CapabilitiesConnectorControlHandle,
    },
}

impl CapabilitiesConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(
        String,
        fidl::endpoints::ServerEnd<ThreadCapabilitiesMarker>,
        CapabilitiesConnectorControlHandle,
    )> {
        if let CapabilitiesConnectorRequest::Connect { name, server_end, control_handle } = self {
            Some((name, server_end, control_handle))
        } else {
            None
        }
    }

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

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

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

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

impl fidl::endpoints::ProtocolMarker for DatasetMarker {
    type Proxy = DatasetProxy;
    type RequestStream = DatasetRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DatasetSynchronousProxy;

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

pub trait DatasetProxyInterface: Send + Sync {
    type GetActiveTlvsResponseFut: std::future::Future<Output = Result<Option<Vec<u8>>, fidl::Error>>
        + Send;
    fn r#get_active_tlvs(&self) -> Self::GetActiveTlvsResponseFut;
    type SetActiveTlvsResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#set_active_tlvs(&self, dataset: &[u8]) -> Self::SetActiveTlvsResponseFut;
    type AttachAllNodesToResponseFut: std::future::Future<Output = Result<i64, fidl::Error>> + Send;
    fn r#attach_all_nodes_to(&self, dataset: &[u8]) -> Self::AttachAllNodesToResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DatasetSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DatasetSynchronousProxy {
    type Proxy = DatasetProxy;
    type Protocol = DatasetMarker;

    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 DatasetSynchronousProxy {
    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<DatasetEvent, fidl::Error> {
        DatasetEvent::decode(self.client.wait_for_event::<DatasetMarker>(deadline)?)
    }

    /// Fetches and returns the active Thread operational dataset in raw
    /// TLV form. Functionally equivalent to [`otDatasetGetActiveTlvs()`][2].
    ///
    /// This method returns the active dataset, or nothing in the case that
    /// there is no active operational dataset.
    ///
    /// Any error that prevents the operation from completing successfully
    /// will result in the protocol being closed.
    ///
    /// [2]: https://openthread.io/reference/group/api-operational-dataset#otdatasetgetactivetlvs
    pub fn r#get_active_tlvs(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Option<Vec<u8>>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            DatasetGetActiveTlvsResponse,
            DatasetMarker,
        >(
            (),
            0x3004d50d9fb69b92,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.dataset)
    }

    /// Sets the active Thread Operational Dataset in raw TLV form.
    /// Functionally equivalent to [`otDatasetSetActiveTlvs()`][3].
    ///
    /// This method returns once the operation has completed successfully.
    ///
    /// Any error that prevents the operation from completing successfully
    /// will result in the protocol being closed.
    ///
    /// [3]: https://openthread.io/reference/group/api-operational-dataset#otdatasetsetactivetlvs
    pub fn r#set_active_tlvs(
        &self,
        mut dataset: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<DatasetSetActiveTlvsRequest, fidl::encoding::EmptyPayload, DatasetMarker>(
                (dataset,),
                0x5a8dc1d4e3b578e7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Requests that all nodes on the current network attach to the thread
    /// network described by given dataset. Returns the number of milliseconds
    /// until the change takes effect.
    ///
    /// Functionally equivalent to `ot-br-posix`'s [`AttachAllNodesTo`][4].
    ///
    /// If this device is not currently provisioned, then calling this method
    /// is equivalent to calling [`SetActiveTlvs()`].
    ///
    /// The transition of all nodes to the new network may take as long as
    /// five minutes. The exact amount of time until the network is
    /// transitioned is returned by this method.
    ///
    /// This method returns once the transition has been scheduled successfully.
    /// Any error that prevents the scheduling of this operation from
    /// completing successfully (such as being provided with an incomplete
    /// dataset) will result in the protocol being closed.
    ///
    /// [4]: https://github.com/openthread/ot-br-posix/blob/f68c07702bef50f1cc4a153a59b5a3a8331ff43b/src/dbus/server/introspect.xml#L60-L72
    pub fn r#attach_all_nodes_to(
        &self,
        mut dataset: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i64, fidl::Error> {
        let _response = self.client.send_query::<
            DatasetAttachAllNodesToRequest,
            DatasetAttachAllNodesToResponse,
            DatasetMarker,
        >(
            (dataset,),
            0x6057e8b429c4aefe,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.delay_ms)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DatasetProxy {
    type Protocol = DatasetMarker;

    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 DatasetProxy {
    /// Create a new Proxy for fuchsia.lowpan.thread/Dataset.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DatasetMarker 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) -> DatasetEventStream {
        DatasetEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Fetches and returns the active Thread operational dataset in raw
    /// TLV form. Functionally equivalent to [`otDatasetGetActiveTlvs()`][2].
    ///
    /// This method returns the active dataset, or nothing in the case that
    /// there is no active operational dataset.
    ///
    /// Any error that prevents the operation from completing successfully
    /// will result in the protocol being closed.
    ///
    /// [2]: https://openthread.io/reference/group/api-operational-dataset#otdatasetgetactivetlvs
    pub fn r#get_active_tlvs(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Option<Vec<u8>>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatasetProxyInterface::r#get_active_tlvs(self)
    }

    /// Sets the active Thread Operational Dataset in raw TLV form.
    /// Functionally equivalent to [`otDatasetSetActiveTlvs()`][3].
    ///
    /// This method returns once the operation has completed successfully.
    ///
    /// Any error that prevents the operation from completing successfully
    /// will result in the protocol being closed.
    ///
    /// [3]: https://openthread.io/reference/group/api-operational-dataset#otdatasetsetactivetlvs
    pub fn r#set_active_tlvs(
        &self,
        mut dataset: &[u8],
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        DatasetProxyInterface::r#set_active_tlvs(self, dataset)
    }

    /// Requests that all nodes on the current network attach to the thread
    /// network described by given dataset. Returns the number of milliseconds
    /// until the change takes effect.
    ///
    /// Functionally equivalent to `ot-br-posix`'s [`AttachAllNodesTo`][4].
    ///
    /// If this device is not currently provisioned, then calling this method
    /// is equivalent to calling [`SetActiveTlvs()`].
    ///
    /// The transition of all nodes to the new network may take as long as
    /// five minutes. The exact amount of time until the network is
    /// transitioned is returned by this method.
    ///
    /// This method returns once the transition has been scheduled successfully.
    /// Any error that prevents the scheduling of this operation from
    /// completing successfully (such as being provided with an incomplete
    /// dataset) will result in the protocol being closed.
    ///
    /// [4]: https://github.com/openthread/ot-br-posix/blob/f68c07702bef50f1cc4a153a59b5a3a8331ff43b/src/dbus/server/introspect.xml#L60-L72
    pub fn r#attach_all_nodes_to(
        &self,
        mut dataset: &[u8],
    ) -> fidl::client::QueryResponseFut<i64, fidl::encoding::DefaultFuchsiaResourceDialect> {
        DatasetProxyInterface::r#attach_all_nodes_to(self, dataset)
    }
}

impl DatasetProxyInterface for DatasetProxy {
    type GetActiveTlvsResponseFut = fidl::client::QueryResponseFut<
        Option<Vec<u8>>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_active_tlvs(&self) -> Self::GetActiveTlvsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Option<Vec<u8>>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DatasetGetActiveTlvsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3004d50d9fb69b92,
            >(_buf?)?;
            Ok(_response.dataset)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Option<Vec<u8>>>(
            (),
            0x3004d50d9fb69b92,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetActiveTlvsResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_active_tlvs(&self, mut dataset: &[u8]) -> Self::SetActiveTlvsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5a8dc1d4e3b578e7,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<DatasetSetActiveTlvsRequest, ()>(
            (dataset,),
            0x5a8dc1d4e3b578e7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AttachAllNodesToResponseFut =
        fidl::client::QueryResponseFut<i64, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#attach_all_nodes_to(&self, mut dataset: &[u8]) -> Self::AttachAllNodesToResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i64, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DatasetAttachAllNodesToResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6057e8b429c4aefe,
            >(_buf?)?;
            Ok(_response.delay_ms)
        }
        self.client.send_query_and_decode::<DatasetAttachAllNodesToRequest, i64>(
            (dataset,),
            0x6057e8b429c4aefe,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DatasetRequestStream {
    type Protocol = DatasetMarker;
    type ControlHandle = DatasetControlHandle;

    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 {
        DatasetControlHandle { 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 DatasetRequestStream {
    type Item = Result<DatasetRequest, 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 DatasetRequestStream 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 {
                    0x3004d50d9fb69b92 => {
                        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 = DatasetControlHandle { inner: this.inner.clone() };
                        Ok(DatasetRequest::GetActiveTlvs {
                            responder: DatasetGetActiveTlvsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5a8dc1d4e3b578e7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DatasetSetActiveTlvsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DatasetSetActiveTlvsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DatasetControlHandle { inner: this.inner.clone() };
                        Ok(DatasetRequest::SetActiveTlvs {
                            dataset: req.dataset,

                            responder: DatasetSetActiveTlvsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6057e8b429c4aefe => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DatasetAttachAllNodesToRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DatasetAttachAllNodesToRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DatasetControlHandle { inner: this.inner.clone() };
                        Ok(DatasetRequest::AttachAllNodesTo {
                            dataset: req.dataset,

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

/// Thread Operational Dataset Protocol.
///
/// This protocol can expose PII.
///
/// This protocol provides methods related to the management of the
/// Thread operational dataset in raw TLV form.
#[derive(Debug)]
pub enum DatasetRequest {
    /// Fetches and returns the active Thread operational dataset in raw
    /// TLV form. Functionally equivalent to [`otDatasetGetActiveTlvs()`][2].
    ///
    /// This method returns the active dataset, or nothing in the case that
    /// there is no active operational dataset.
    ///
    /// Any error that prevents the operation from completing successfully
    /// will result in the protocol being closed.
    ///
    /// [2]: https://openthread.io/reference/group/api-operational-dataset#otdatasetgetactivetlvs
    GetActiveTlvs { responder: DatasetGetActiveTlvsResponder },
    /// Sets the active Thread Operational Dataset in raw TLV form.
    /// Functionally equivalent to [`otDatasetSetActiveTlvs()`][3].
    ///
    /// This method returns once the operation has completed successfully.
    ///
    /// Any error that prevents the operation from completing successfully
    /// will result in the protocol being closed.
    ///
    /// [3]: https://openthread.io/reference/group/api-operational-dataset#otdatasetsetactivetlvs
    SetActiveTlvs { dataset: Vec<u8>, responder: DatasetSetActiveTlvsResponder },
    /// Requests that all nodes on the current network attach to the thread
    /// network described by given dataset. Returns the number of milliseconds
    /// until the change takes effect.
    ///
    /// Functionally equivalent to `ot-br-posix`'s [`AttachAllNodesTo`][4].
    ///
    /// If this device is not currently provisioned, then calling this method
    /// is equivalent to calling [`SetActiveTlvs()`].
    ///
    /// The transition of all nodes to the new network may take as long as
    /// five minutes. The exact amount of time until the network is
    /// transitioned is returned by this method.
    ///
    /// This method returns once the transition has been scheduled successfully.
    /// Any error that prevents the scheduling of this operation from
    /// completing successfully (such as being provided with an incomplete
    /// dataset) will result in the protocol being closed.
    ///
    /// [4]: https://github.com/openthread/ot-br-posix/blob/f68c07702bef50f1cc4a153a59b5a3a8331ff43b/src/dbus/server/introspect.xml#L60-L72
    AttachAllNodesTo { dataset: Vec<u8>, responder: DatasetAttachAllNodesToResponder },
}

impl DatasetRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_active_tlvs(self) -> Option<(DatasetGetActiveTlvsResponder)> {
        if let DatasetRequest::GetActiveTlvs { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_active_tlvs(self) -> Option<(Vec<u8>, DatasetSetActiveTlvsResponder)> {
        if let DatasetRequest::SetActiveTlvs { dataset, responder } = self {
            Some((dataset, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_attach_all_nodes_to(self) -> Option<(Vec<u8>, DatasetAttachAllNodesToResponder)> {
        if let DatasetRequest::AttachAllNodesTo { dataset, responder } = self {
            Some((dataset, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DatasetRequest::GetActiveTlvs { .. } => "get_active_tlvs",
            DatasetRequest::SetActiveTlvs { .. } => "set_active_tlvs",
            DatasetRequest::AttachAllNodesTo { .. } => "attach_all_nodes_to",
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut dataset: Option<&[u8]>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DatasetGetActiveTlvsResponse>(
            (dataset,),
            self.tx_id,
            0x3004d50d9fb69b92,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x5a8dc1d4e3b578e7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut delay_ms: i64) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DatasetAttachAllNodesToResponse>(
            (delay_ms,),
            self.tx_id,
            0x6057e8b429c4aefe,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for DatasetConnectorMarker {
    type Proxy = DatasetConnectorProxy;
    type RequestStream = DatasetConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DatasetConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.lowpan.thread.DatasetConnector";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DatasetConnectorMarker {}

pub trait DatasetConnectorProxyInterface: Send + Sync {
    fn r#connect(
        &self,
        name: &str,
        server_end: fidl::endpoints::ServerEnd<DatasetMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DatasetConnectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DatasetConnectorSynchronousProxy {
    type Proxy = DatasetConnectorProxy;
    type Protocol = DatasetConnectorMarker;

    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 DatasetConnectorSynchronousProxy {
    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<DatasetConnectorEvent, fidl::Error> {
        DatasetConnectorEvent::decode(
            self.client.wait_for_event::<DatasetConnectorMarker>(deadline)?,
        )
    }

    /// Connects to the [`Dataset`] protocol on the
    /// named LoWPAN device.
    ///
    /// The name of the interface can be learned by calling
    /// [`fuchsia.lowpan/Lookup.GetDevices`].
    ///
    /// If there is an error in processing this request
    /// the given channel is closed and an epitaph code used
    /// to describe the reason for the failure:
    ///
    /// * `ZX_ERR_INVALID_ARGUMENT`: The given interface name
    ///   was not formatted correctly or otherwise invalid.
    /// * `ZX_ERR_NOT_FOUND`: No interface was found with the
    ///   given name.
    /// * `ZX_ERR_NOT_SUPPORTED`: The interface exists but
    ///   does not support this protocol.
    pub fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<DatasetMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DatasetConnectorConnectRequest>(
            (name, server_end),
            0x24dff5d2c0cee02b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DatasetConnectorProxy {
    type Protocol = DatasetConnectorMarker;

    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 DatasetConnectorProxy {
    /// Create a new Proxy for fuchsia.lowpan.thread/DatasetConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DatasetConnectorMarker 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) -> DatasetConnectorEventStream {
        DatasetConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connects to the [`Dataset`] protocol on the
    /// named LoWPAN device.
    ///
    /// The name of the interface can be learned by calling
    /// [`fuchsia.lowpan/Lookup.GetDevices`].
    ///
    /// If there is an error in processing this request
    /// the given channel is closed and an epitaph code used
    /// to describe the reason for the failure:
    ///
    /// * `ZX_ERR_INVALID_ARGUMENT`: The given interface name
    ///   was not formatted correctly or otherwise invalid.
    /// * `ZX_ERR_NOT_FOUND`: No interface was found with the
    ///   given name.
    /// * `ZX_ERR_NOT_SUPPORTED`: The interface exists but
    ///   does not support this protocol.
    pub fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<DatasetMarker>,
    ) -> Result<(), fidl::Error> {
        DatasetConnectorProxyInterface::r#connect(self, name, server_end)
    }
}

impl DatasetConnectorProxyInterface for DatasetConnectorProxy {
    fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<DatasetMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DatasetConnectorConnectRequest>(
            (name, server_end),
            0x24dff5d2c0cee02b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DatasetConnectorRequestStream {
    type Protocol = DatasetConnectorMarker;
    type ControlHandle = DatasetConnectorControlHandle;

    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 {
        DatasetConnectorControlHandle { 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 DatasetConnectorRequestStream {
    type Item = Result<DatasetConnectorRequest, 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 DatasetConnectorRequestStream 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 {
                    0x24dff5d2c0cee02b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DatasetConnectorConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DatasetConnectorConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatasetConnectorControlHandle { inner: this.inner.clone() };
                        Ok(DatasetConnectorRequest::Connect {
                            name: req.name,
                            server_end: req.server_end,

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

/// Protocol for connecting to [`Dataset`] on a LoWPAN device.
#[derive(Debug)]
pub enum DatasetConnectorRequest {
    /// Connects to the [`Dataset`] protocol on the
    /// named LoWPAN device.
    ///
    /// The name of the interface can be learned by calling
    /// [`fuchsia.lowpan/Lookup.GetDevices`].
    ///
    /// If there is an error in processing this request
    /// the given channel is closed and an epitaph code used
    /// to describe the reason for the failure:
    ///
    /// * `ZX_ERR_INVALID_ARGUMENT`: The given interface name
    ///   was not formatted correctly or otherwise invalid.
    /// * `ZX_ERR_NOT_FOUND`: No interface was found with the
    ///   given name.
    /// * `ZX_ERR_NOT_SUPPORTED`: The interface exists but
    ///   does not support this protocol.
    Connect {
        name: String,
        server_end: fidl::endpoints::ServerEnd<DatasetMarker>,
        control_handle: DatasetConnectorControlHandle,
    },
}

impl DatasetConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(String, fidl::endpoints::ServerEnd<DatasetMarker>, DatasetConnectorControlHandle)>
    {
        if let DatasetConnectorRequest::Connect { name, server_end, control_handle } = self {
            Some((name, server_end, control_handle))
        } else {
            None
        }
    }

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

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

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

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

impl fidl::endpoints::ProtocolMarker for EpskcMarker {
    type Proxy = EpskcProxy;
    type RequestStream = EpskcRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = EpskcSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Epskc";
}
pub type EpskcStartEphemeralKeyResult = Result<Vec<u8>, i32>;
pub type EpskcStopEphemeralKeyResult = Result<(), i32>;

pub trait EpskcProxyInterface: Send + Sync {
    type StartEphemeralKeyResponseFut: std::future::Future<Output = Result<EpskcStartEphemeralKeyResult, fidl::Error>>
        + Send;
    fn r#start_ephemeral_key(&self, lifetime: u32) -> Self::StartEphemeralKeyResponseFut;
    type StopEphemeralKeyResponseFut: std::future::Future<Output = Result<EpskcStopEphemeralKeyResult, fidl::Error>>
        + Send;
    fn r#stop_ephemeral_key(
        &self,
        retain_active_session: bool,
    ) -> Self::StopEphemeralKeyResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct EpskcSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for EpskcSynchronousProxy {
    type Proxy = EpskcProxy;
    type Protocol = EpskcMarker;

    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 EpskcSynchronousProxy {
    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<EpskcEvent, fidl::Error> {
        EpskcEvent::decode(self.client.wait_for_event::<EpskcMarker>(deadline)?)
    }

    /// Starts the ephemeral key handler.
    ///
    /// The ePSKc functionality must first be enabled via
    /// fuchsia.lowpan.thread/FeatureConnector.
    ///
    /// The lifetime is in units of milliseconds.
    ///
    /// From OpenThread:
    ///
    /// When successfully set, the ephemeral key can be used only once by an
    /// external commissioner candidate to establish a secure session. After the
    /// commissioner candidate disconnects, the use of the ephemeral key is
    /// stopped.
    ///
    /// The maximum ephemeral key lifetime is 10 minutes.
    ///
    /// If a lifetime of 0 is provided, OpenThread will use its default lifetime
    /// of 2 minutes.
    ///
    /// If the lifetime expires, the use of the ephemeral key is stopped, and
    /// any connected session using the key is immediately disconnected.
    ///
    /// The Ephemeral Key Manager limits the number of failed DTLS connections
    /// to 10 attempts. After the 10th failed attempt, the use of the ephemeral
    /// key is automatically stopped (even if the lifetime has not yet expired).
    ///
    /// * `ZX_ERR_INVALID_ARGS`: The specified lifetime is greater than allowed.
    /// * `ZX_ERR_BAD_STATE`: The ePSKc functionality has not been enabled.
    /// * `ZX_ERR_INTERNAL`: There was a failure in generating the ephemeral key.`
    pub fn r#start_ephemeral_key(
        &self,
        mut lifetime: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EpskcStartEphemeralKeyResult, fidl::Error> {
        let _response = self.client.send_query::<
            EpskcStartEphemeralKeyRequest,
            fidl::encoding::FlexibleResultType<EpskcStartEphemeralKeyResponse, i32>,
            EpskcMarker,
        >(
            (lifetime,),
            0x215e7ca3dab0a8b7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<EpskcMarker>("start_ephemeral_key")?;
        Ok(_response.map(|x| x.key))
    }

    /// Stops the ephemeral key use.
    ///
    /// Existing sessions are terminated if retain_active_session is false.
    /// If retain_active_session is true and there is an ongoing session, the
    /// ephemeral key is not stopped.
    ///
    /// The ePSKc functionality must first be enabled via
    /// fuchsia.lowpan.thread/FeatureConnector.
    ///
    /// * `ZX_ERR_BAD_STATE`: The ePSKc functionality has not been enabled or
    ///   `retain_active_session` is true and there is an active session.
    pub fn r#stop_ephemeral_key(
        &self,
        mut retain_active_session: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EpskcStopEphemeralKeyResult, fidl::Error> {
        let _response = self.client.send_query::<
            EpskcStopEphemeralKeyRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
            EpskcMarker,
        >(
            (retain_active_session,),
            0x33a89ab1cfd88906,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<EpskcMarker>("stop_ephemeral_key")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for EpskcProxy {
    type Protocol = EpskcMarker;

    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 EpskcProxy {
    /// Create a new Proxy for fuchsia.lowpan.thread/Epskc.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <EpskcMarker 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) -> EpskcEventStream {
        EpskcEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Starts the ephemeral key handler.
    ///
    /// The ePSKc functionality must first be enabled via
    /// fuchsia.lowpan.thread/FeatureConnector.
    ///
    /// The lifetime is in units of milliseconds.
    ///
    /// From OpenThread:
    ///
    /// When successfully set, the ephemeral key can be used only once by an
    /// external commissioner candidate to establish a secure session. After the
    /// commissioner candidate disconnects, the use of the ephemeral key is
    /// stopped.
    ///
    /// The maximum ephemeral key lifetime is 10 minutes.
    ///
    /// If a lifetime of 0 is provided, OpenThread will use its default lifetime
    /// of 2 minutes.
    ///
    /// If the lifetime expires, the use of the ephemeral key is stopped, and
    /// any connected session using the key is immediately disconnected.
    ///
    /// The Ephemeral Key Manager limits the number of failed DTLS connections
    /// to 10 attempts. After the 10th failed attempt, the use of the ephemeral
    /// key is automatically stopped (even if the lifetime has not yet expired).
    ///
    /// * `ZX_ERR_INVALID_ARGS`: The specified lifetime is greater than allowed.
    /// * `ZX_ERR_BAD_STATE`: The ePSKc functionality has not been enabled.
    /// * `ZX_ERR_INTERNAL`: There was a failure in generating the ephemeral key.`
    pub fn r#start_ephemeral_key(
        &self,
        mut lifetime: u32,
    ) -> fidl::client::QueryResponseFut<
        EpskcStartEphemeralKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        EpskcProxyInterface::r#start_ephemeral_key(self, lifetime)
    }

    /// Stops the ephemeral key use.
    ///
    /// Existing sessions are terminated if retain_active_session is false.
    /// If retain_active_session is true and there is an ongoing session, the
    /// ephemeral key is not stopped.
    ///
    /// The ePSKc functionality must first be enabled via
    /// fuchsia.lowpan.thread/FeatureConnector.
    ///
    /// * `ZX_ERR_BAD_STATE`: The ePSKc functionality has not been enabled or
    ///   `retain_active_session` is true and there is an active session.
    pub fn r#stop_ephemeral_key(
        &self,
        mut retain_active_session: bool,
    ) -> fidl::client::QueryResponseFut<
        EpskcStopEphemeralKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        EpskcProxyInterface::r#stop_ephemeral_key(self, retain_active_session)
    }
}

impl EpskcProxyInterface for EpskcProxy {
    type StartEphemeralKeyResponseFut = fidl::client::QueryResponseFut<
        EpskcStartEphemeralKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start_ephemeral_key(&self, mut lifetime: u32) -> Self::StartEphemeralKeyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EpskcStartEphemeralKeyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<EpskcStartEphemeralKeyResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x215e7ca3dab0a8b7,
            >(_buf?)?
            .into_result::<EpskcMarker>("start_ephemeral_key")?;
            Ok(_response.map(|x| x.key))
        }
        self.client
            .send_query_and_decode::<EpskcStartEphemeralKeyRequest, EpskcStartEphemeralKeyResult>(
                (lifetime,),
                0x215e7ca3dab0a8b7,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type StopEphemeralKeyResponseFut = fidl::client::QueryResponseFut<
        EpskcStopEphemeralKeyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#stop_ephemeral_key(
        &self,
        mut retain_active_session: bool,
    ) -> Self::StopEphemeralKeyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EpskcStopEphemeralKeyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x33a89ab1cfd88906,
            >(_buf?)?
            .into_result::<EpskcMarker>("stop_ephemeral_key")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<EpskcStopEphemeralKeyRequest, EpskcStopEphemeralKeyResult>(
                (retain_active_session,),
                0x33a89ab1cfd88906,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for EpskcRequestStream {
    type Protocol = EpskcMarker;
    type ControlHandle = EpskcControlHandle;

    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 {
        EpskcControlHandle { 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 EpskcRequestStream {
    type Item = Result<EpskcRequest, 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 EpskcRequestStream 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 {
                    0x215e7ca3dab0a8b7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            EpskcStartEphemeralKeyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EpskcStartEphemeralKeyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = EpskcControlHandle { inner: this.inner.clone() };
                        Ok(EpskcRequest::StartEphemeralKey {
                            lifetime: req.lifetime,

                            responder: EpskcStartEphemeralKeyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x33a89ab1cfd88906 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            EpskcStopEphemeralKeyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EpskcStopEphemeralKeyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = EpskcControlHandle { inner: this.inner.clone() };
                        Ok(EpskcRequest::StopEphemeralKey {
                            retain_active_session: req.retain_active_session,

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

/// ePSKc configuration protocol
///
/// This allows callers to interact with the Thread stack's ePSKc functionality
/// to produce or invalidate ephemeral keys.
#[derive(Debug)]
pub enum EpskcRequest {
    /// Starts the ephemeral key handler.
    ///
    /// The ePSKc functionality must first be enabled via
    /// fuchsia.lowpan.thread/FeatureConnector.
    ///
    /// The lifetime is in units of milliseconds.
    ///
    /// From OpenThread:
    ///
    /// When successfully set, the ephemeral key can be used only once by an
    /// external commissioner candidate to establish a secure session. After the
    /// commissioner candidate disconnects, the use of the ephemeral key is
    /// stopped.
    ///
    /// The maximum ephemeral key lifetime is 10 minutes.
    ///
    /// If a lifetime of 0 is provided, OpenThread will use its default lifetime
    /// of 2 minutes.
    ///
    /// If the lifetime expires, the use of the ephemeral key is stopped, and
    /// any connected session using the key is immediately disconnected.
    ///
    /// The Ephemeral Key Manager limits the number of failed DTLS connections
    /// to 10 attempts. After the 10th failed attempt, the use of the ephemeral
    /// key is automatically stopped (even if the lifetime has not yet expired).
    ///
    /// * `ZX_ERR_INVALID_ARGS`: The specified lifetime is greater than allowed.
    /// * `ZX_ERR_BAD_STATE`: The ePSKc functionality has not been enabled.
    /// * `ZX_ERR_INTERNAL`: There was a failure in generating the ephemeral key.`
    StartEphemeralKey { lifetime: u32, responder: EpskcStartEphemeralKeyResponder },
    /// Stops the ephemeral key use.
    ///
    /// Existing sessions are terminated if retain_active_session is false.
    /// If retain_active_session is true and there is an ongoing session, the
    /// ephemeral key is not stopped.
    ///
    /// The ePSKc functionality must first be enabled via
    /// fuchsia.lowpan.thread/FeatureConnector.
    ///
    /// * `ZX_ERR_BAD_STATE`: The ePSKc functionality has not been enabled or
    ///   `retain_active_session` is true and there is an active session.
    StopEphemeralKey { retain_active_session: bool, responder: EpskcStopEphemeralKeyResponder },
    /// 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: EpskcControlHandle,
        method_type: fidl::MethodType,
    },
}

impl EpskcRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_start_ephemeral_key(self) -> Option<(u32, EpskcStartEphemeralKeyResponder)> {
        if let EpskcRequest::StartEphemeralKey { lifetime, responder } = self {
            Some((lifetime, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_ephemeral_key(self) -> Option<(bool, EpskcStopEphemeralKeyResponder)> {
        if let EpskcRequest::StopEphemeralKey { retain_active_session, responder } = self {
            Some((retain_active_session, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for EpskcConnectorMarker {
    type Proxy = EpskcConnectorProxy;
    type RequestStream = EpskcConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = EpskcConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.lowpan.thread.EpskcConnector";
}
impl fidl::endpoints::DiscoverableProtocolMarker for EpskcConnectorMarker {}

pub trait EpskcConnectorProxyInterface: Send + Sync {
    fn r#connect(
        &self,
        name: &str,
        server_end: fidl::endpoints::ServerEnd<EpskcMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct EpskcConnectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for EpskcConnectorSynchronousProxy {
    type Proxy = EpskcConnectorProxy;
    type Protocol = EpskcConnectorMarker;

    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 EpskcConnectorSynchronousProxy {
    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<EpskcConnectorEvent, fidl::Error> {
        EpskcConnectorEvent::decode(self.client.wait_for_event::<EpskcConnectorMarker>(deadline)?)
    }

    /// Connects to the [`Epskc`] protocol on the
    /// named LoWPAN device.
    ///
    /// The name of the interface can be learned by calling
    /// [`fuchsia.lowpan/Lookup.GetDevices`].
    ///
    /// If there is an error in processing this request
    /// the given channel is closed and an epitaph code used
    /// to describe the reason for the failure:
    ///
    /// * `ZX_ERR_INVALID_ARGUMENT`: The given interface name
    ///   was not formatted correctly or otherwise invalid.
    /// * `ZX_ERR_NOT_FOUND`: No interface was found with the
    ///   given name.
    /// * `ZX_ERR_NOT_SUPPORTED`: The interface exists but
    ///   does not support this protocol.
    pub fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<EpskcMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<EpskcConnectorConnectRequest>(
            (name, server_end),
            0x1df4842606b2f03c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for EpskcConnectorProxy {
    type Protocol = EpskcConnectorMarker;

    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 EpskcConnectorProxy {
    /// Create a new Proxy for fuchsia.lowpan.thread/EpskcConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <EpskcConnectorMarker 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) -> EpskcConnectorEventStream {
        EpskcConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connects to the [`Epskc`] protocol on the
    /// named LoWPAN device.
    ///
    /// The name of the interface can be learned by calling
    /// [`fuchsia.lowpan/Lookup.GetDevices`].
    ///
    /// If there is an error in processing this request
    /// the given channel is closed and an epitaph code used
    /// to describe the reason for the failure:
    ///
    /// * `ZX_ERR_INVALID_ARGUMENT`: The given interface name
    ///   was not formatted correctly or otherwise invalid.
    /// * `ZX_ERR_NOT_FOUND`: No interface was found with the
    ///   given name.
    /// * `ZX_ERR_NOT_SUPPORTED`: The interface exists but
    ///   does not support this protocol.
    pub fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<EpskcMarker>,
    ) -> Result<(), fidl::Error> {
        EpskcConnectorProxyInterface::r#connect(self, name, server_end)
    }
}

impl EpskcConnectorProxyInterface for EpskcConnectorProxy {
    fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<EpskcMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<EpskcConnectorConnectRequest>(
            (name, server_end),
            0x1df4842606b2f03c,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for EpskcConnectorRequestStream {
    type Protocol = EpskcConnectorMarker;
    type ControlHandle = EpskcConnectorControlHandle;

    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 {
        EpskcConnectorControlHandle { 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 EpskcConnectorRequestStream {
    type Item = Result<EpskcConnectorRequest, 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 EpskcConnectorRequestStream 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 {
                    0x1df4842606b2f03c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            EpskcConnectorConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EpskcConnectorConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            EpskcConnectorControlHandle { inner: this.inner.clone() };
                        Ok(EpskcConnectorRequest::Connect {
                            name: req.name,
                            server_end: req.server_end,

                            control_handle,
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(EpskcConnectorRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: EpskcConnectorControlHandle {
                                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(EpskcConnectorRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: EpskcConnectorControlHandle {
                                inner: this.inner.clone(),
                            },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <EpskcConnectorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol for connecting to [`Epskc`] on a LoWPAN device.
#[derive(Debug)]
pub enum EpskcConnectorRequest {
    /// Connects to the [`Epskc`] protocol on the
    /// named LoWPAN device.
    ///
    /// The name of the interface can be learned by calling
    /// [`fuchsia.lowpan/Lookup.GetDevices`].
    ///
    /// If there is an error in processing this request
    /// the given channel is closed and an epitaph code used
    /// to describe the reason for the failure:
    ///
    /// * `ZX_ERR_INVALID_ARGUMENT`: The given interface name
    ///   was not formatted correctly or otherwise invalid.
    /// * `ZX_ERR_NOT_FOUND`: No interface was found with the
    ///   given name.
    /// * `ZX_ERR_NOT_SUPPORTED`: The interface exists but
    ///   does not support this protocol.
    Connect {
        name: String,
        server_end: fidl::endpoints::ServerEnd<EpskcMarker>,
        control_handle: EpskcConnectorControlHandle,
    },
    /// 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: EpskcConnectorControlHandle,
        method_type: fidl::MethodType,
    },
}

impl EpskcConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(String, fidl::endpoints::ServerEnd<EpskcMarker>, EpskcConnectorControlHandle)>
    {
        if let EpskcConnectorRequest::Connect { name, server_end, control_handle } = self {
            Some((name, server_end, control_handle))
        } else {
            None
        }
    }

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

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

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

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

impl fidl::endpoints::ProtocolMarker for FeatureMarker {
    type Proxy = FeatureProxy;
    type RequestStream = FeatureRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = FeatureSynchronousProxy;

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

pub trait FeatureProxyInterface: Send + Sync {
    type UpdateFeatureConfigResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#update_feature_config(
        &self,
        config: &FeatureConfig,
    ) -> Self::UpdateFeatureConfigResponseFut;
    type GetFeatureConfigResponseFut: std::future::Future<Output = Result<FeatureConfig, fidl::Error>>
        + Send;
    fn r#get_feature_config(&self) -> Self::GetFeatureConfigResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct FeatureSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for FeatureSynchronousProxy {
    type Proxy = FeatureProxy;
    type Protocol = FeatureMarker;

    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 FeatureSynchronousProxy {
    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<FeatureEvent, fidl::Error> {
        FeatureEvent::decode(self.client.wait_for_event::<FeatureMarker>(deadline)?)
    }

    /// Updates the current OpenThread feature configuration for this
    /// interface.
    ///
    /// Any unset field in `config` will leave that field unchanged.
    pub fn r#update_feature_config(
        &self,
        mut config: &FeatureConfig,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            FeatureUpdateFeatureConfigRequest,
            fidl::encoding::EmptyPayload,
            FeatureMarker,
        >(
            (config,),
            0x2d24a706e8730410,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Returns the current OpenThread feature configuration for this
    /// interface.
    ///
    /// A unset field in the returned value means that feature is not
    /// supported.
    pub fn r#get_feature_config(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FeatureConfig, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            FeatureGetFeatureConfigResponse,
            FeatureMarker,
        >(
            (),
            0x2ab1896aea843611,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.config)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for FeatureProxy {
    type Protocol = FeatureMarker;

    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 FeatureProxy {
    /// Create a new Proxy for fuchsia.lowpan.thread/Feature.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <FeatureMarker 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) -> FeatureEventStream {
        FeatureEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Updates the current OpenThread feature configuration for this
    /// interface.
    ///
    /// Any unset field in `config` will leave that field unchanged.
    pub fn r#update_feature_config(
        &self,
        mut config: &FeatureConfig,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        FeatureProxyInterface::r#update_feature_config(self, config)
    }

    /// Returns the current OpenThread feature configuration for this
    /// interface.
    ///
    /// A unset field in the returned value means that feature is not
    /// supported.
    pub fn r#get_feature_config(
        &self,
    ) -> fidl::client::QueryResponseFut<FeatureConfig, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        FeatureProxyInterface::r#get_feature_config(self)
    }
}

impl FeatureProxyInterface for FeatureProxy {
    type UpdateFeatureConfigResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#update_feature_config(
        &self,
        mut config: &FeatureConfig,
    ) -> Self::UpdateFeatureConfigResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2d24a706e8730410,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<FeatureUpdateFeatureConfigRequest, ()>(
            (config,),
            0x2d24a706e8730410,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetFeatureConfigResponseFut = fidl::client::QueryResponseFut<
        FeatureConfig,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_feature_config(&self) -> Self::GetFeatureConfigResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FeatureConfig, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                FeatureGetFeatureConfigResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2ab1896aea843611,
            >(_buf?)?;
            Ok(_response.config)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, FeatureConfig>(
            (),
            0x2ab1896aea843611,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for FeatureRequestStream {
    type Protocol = FeatureMarker;
    type ControlHandle = FeatureControlHandle;

    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 {
        FeatureControlHandle { 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 FeatureRequestStream {
    type Item = Result<FeatureRequest, 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 FeatureRequestStream 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 {
                    0x2d24a706e8730410 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FeatureUpdateFeatureConfigRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FeatureUpdateFeatureConfigRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FeatureControlHandle { inner: this.inner.clone() };
                        Ok(FeatureRequest::UpdateFeatureConfig {
                            config: req.config,

                            responder: FeatureUpdateFeatureConfigResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2ab1896aea843611 => {
                        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 = FeatureControlHandle { inner: this.inner.clone() };
                        Ok(FeatureRequest::GetFeatureConfig {
                            responder: FeatureGetFeatureConfigResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <FeatureMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol for fetching and updating the OpenThread feature configuration
/// for a specific LoWPAN interface.
#[derive(Debug)]
pub enum FeatureRequest {
    /// Updates the current OpenThread feature configuration for this
    /// interface.
    ///
    /// Any unset field in `config` will leave that field unchanged.
    UpdateFeatureConfig { config: FeatureConfig, responder: FeatureUpdateFeatureConfigResponder },
    /// Returns the current OpenThread feature configuration for this
    /// interface.
    ///
    /// A unset field in the returned value means that feature is not
    /// supported.
    GetFeatureConfig { responder: FeatureGetFeatureConfigResponder },
}

impl FeatureRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_update_feature_config(
        self,
    ) -> Option<(FeatureConfig, FeatureUpdateFeatureConfigResponder)> {
        if let FeatureRequest::UpdateFeatureConfig { config, responder } = self {
            Some((config, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_feature_config(self) -> Option<(FeatureGetFeatureConfigResponder)> {
        if let FeatureRequest::GetFeatureConfig { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            FeatureRequest::UpdateFeatureConfig { .. } => "update_feature_config",
            FeatureRequest::GetFeatureConfig { .. } => "get_feature_config",
        }
    }
}

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

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

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

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

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

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x2d24a706e8730410,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut config: &FeatureConfig) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<FeatureGetFeatureConfigResponse>(
            (config,),
            self.tx_id,
            0x2ab1896aea843611,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for FeatureConnectorMarker {
    type Proxy = FeatureConnectorProxy;
    type RequestStream = FeatureConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = FeatureConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.lowpan.thread.FeatureConnector";
}
impl fidl::endpoints::DiscoverableProtocolMarker for FeatureConnectorMarker {}

pub trait FeatureConnectorProxyInterface: Send + Sync {
    fn r#connect(
        &self,
        name: &str,
        server_end: fidl::endpoints::ServerEnd<FeatureMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct FeatureConnectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for FeatureConnectorSynchronousProxy {
    type Proxy = FeatureConnectorProxy;
    type Protocol = FeatureConnectorMarker;

    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 FeatureConnectorSynchronousProxy {
    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<FeatureConnectorEvent, fidl::Error> {
        FeatureConnectorEvent::decode(
            self.client.wait_for_event::<FeatureConnectorMarker>(deadline)?,
        )
    }

    /// Connects to the [`Feature`] protocol on the
    /// named LoWPAN device.
    ///
    /// The name of the interface can be learned by calling
    /// [`fuchsia.lowpan/Lookup.GetDevices`].
    ///
    /// If there is an error in processing this request
    /// the given channel is closed and an epitaph code used
    /// to describe the reason for the failure:
    ///
    /// * `ZX_ERR_INVALID_ARGUMENT`: The given interface name
    ///   was not formatted correctly or otherwise invalid.
    /// * `ZX_ERR_NOT_FOUND`: No interface was found with the
    ///   given name.
    /// * `ZX_ERR_NOT_SUPPORTED`: The interface exists but
    ///   does not support this protocol.
    pub fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<FeatureMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FeatureConnectorConnectRequest>(
            (name, server_end),
            0x470f006d630987a5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for FeatureConnectorProxy {
    type Protocol = FeatureConnectorMarker;

    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 FeatureConnectorProxy {
    /// Create a new Proxy for fuchsia.lowpan.thread/FeatureConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <FeatureConnectorMarker 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) -> FeatureConnectorEventStream {
        FeatureConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connects to the [`Feature`] protocol on the
    /// named LoWPAN device.
    ///
    /// The name of the interface can be learned by calling
    /// [`fuchsia.lowpan/Lookup.GetDevices`].
    ///
    /// If there is an error in processing this request
    /// the given channel is closed and an epitaph code used
    /// to describe the reason for the failure:
    ///
    /// * `ZX_ERR_INVALID_ARGUMENT`: The given interface name
    ///   was not formatted correctly or otherwise invalid.
    /// * `ZX_ERR_NOT_FOUND`: No interface was found with the
    ///   given name.
    /// * `ZX_ERR_NOT_SUPPORTED`: The interface exists but
    ///   does not support this protocol.
    pub fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<FeatureMarker>,
    ) -> Result<(), fidl::Error> {
        FeatureConnectorProxyInterface::r#connect(self, name, server_end)
    }
}

impl FeatureConnectorProxyInterface for FeatureConnectorProxy {
    fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<FeatureMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FeatureConnectorConnectRequest>(
            (name, server_end),
            0x470f006d630987a5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for FeatureConnectorRequestStream {
    type Protocol = FeatureConnectorMarker;
    type ControlHandle = FeatureConnectorControlHandle;

    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 {
        FeatureConnectorControlHandle { 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 FeatureConnectorRequestStream {
    type Item = Result<FeatureConnectorRequest, 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 FeatureConnectorRequestStream 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 {
                    0x470f006d630987a5 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FeatureConnectorConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FeatureConnectorConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            FeatureConnectorControlHandle { inner: this.inner.clone() };
                        Ok(FeatureConnectorRequest::Connect {
                            name: req.name,
                            server_end: req.server_end,

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

/// Protocol for connecting to [`Feature`] on a LoWPAN device.
#[derive(Debug)]
pub enum FeatureConnectorRequest {
    /// Connects to the [`Feature`] protocol on the
    /// named LoWPAN device.
    ///
    /// The name of the interface can be learned by calling
    /// [`fuchsia.lowpan/Lookup.GetDevices`].
    ///
    /// If there is an error in processing this request
    /// the given channel is closed and an epitaph code used
    /// to describe the reason for the failure:
    ///
    /// * `ZX_ERR_INVALID_ARGUMENT`: The given interface name
    ///   was not formatted correctly or otherwise invalid.
    /// * `ZX_ERR_NOT_FOUND`: No interface was found with the
    ///   given name.
    /// * `ZX_ERR_NOT_SUPPORTED`: The interface exists but
    ///   does not support this protocol.
    Connect {
        name: String,
        server_end: fidl::endpoints::ServerEnd<FeatureMarker>,
        control_handle: FeatureConnectorControlHandle,
    },
}

impl FeatureConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(String, fidl::endpoints::ServerEnd<FeatureMarker>, FeatureConnectorControlHandle)>
    {
        if let FeatureConnectorRequest::Connect { name, server_end, control_handle } = self {
            Some((name, server_end, control_handle))
        } else {
            None
        }
    }

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

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

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

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

impl fidl::endpoints::ProtocolMarker for MeshcopMarker {
    type Proxy = MeshcopProxy;
    type RequestStream = MeshcopRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = MeshcopSynchronousProxy;

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

pub trait MeshcopProxyInterface: Send + Sync {
    type UpdateTxtEntriesResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#update_txt_entries(&self, txt_entries: &[TxtEntries])
    -> Self::UpdateTxtEntriesResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct MeshcopSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for MeshcopSynchronousProxy {
    type Proxy = MeshcopProxy;
    type Protocol = MeshcopMarker;

    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 MeshcopSynchronousProxy {
    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<MeshcopEvent, fidl::Error> {
        MeshcopEvent::decode(self.client.wait_for_event::<MeshcopMarker>(deadline)?)
    }

    /// Updates the TXT record information associated with the Meshcop border
    /// agent DNS-SD entry. This allows additional information about the
    /// device to be discoverable on the local network when acting as a
    /// border agent.
    ///
    /// Functionally equivalent to `ot-br-posix`'s
    /// [`UpdateVendorMeshCopTxtEntries`][1].
    ///
    /// Typically, the following keys are updated:
    ///
    /// * `vn`: Vendor Name
    /// * `mn`: Model Name
    /// * `vo`: Vendor OUI
    /// * `vd`/`vcd`: Vendor-specific Data
    ///
    /// See table 8-4 in section 8.4.1.1.2 of the Thread 1.2 specification for
    /// a detailed explanation of all the keys and their values.
    ///
    /// Any error that prevents the operation from completing successfully
    /// (such as being provided with invalid keys) will result in the
    /// protocol being closed.
    ///
    /// [1]: https://github.com/openthread/ot-br-posix/blob/0b5c6e1ecb8152ef6cea57c09b8a37a020fc4d6f/src/dbus/server/introspect.xml#L196-L210
    pub fn r#update_txt_entries(
        &self,
        mut txt_entries: &[TxtEntries],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            MeshcopUpdateTxtEntriesRequest,
            fidl::encoding::EmptyPayload,
            MeshcopMarker,
        >(
            (txt_entries,),
            0x358d4d9593140bed,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for MeshcopProxy {
    type Protocol = MeshcopMarker;

    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 MeshcopProxy {
    /// Create a new Proxy for fuchsia.lowpan.thread/Meshcop.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <MeshcopMarker 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) -> MeshcopEventStream {
        MeshcopEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Updates the TXT record information associated with the Meshcop border
    /// agent DNS-SD entry. This allows additional information about the
    /// device to be discoverable on the local network when acting as a
    /// border agent.
    ///
    /// Functionally equivalent to `ot-br-posix`'s
    /// [`UpdateVendorMeshCopTxtEntries`][1].
    ///
    /// Typically, the following keys are updated:
    ///
    /// * `vn`: Vendor Name
    /// * `mn`: Model Name
    /// * `vo`: Vendor OUI
    /// * `vd`/`vcd`: Vendor-specific Data
    ///
    /// See table 8-4 in section 8.4.1.1.2 of the Thread 1.2 specification for
    /// a detailed explanation of all the keys and their values.
    ///
    /// Any error that prevents the operation from completing successfully
    /// (such as being provided with invalid keys) will result in the
    /// protocol being closed.
    ///
    /// [1]: https://github.com/openthread/ot-br-posix/blob/0b5c6e1ecb8152ef6cea57c09b8a37a020fc4d6f/src/dbus/server/introspect.xml#L196-L210
    pub fn r#update_txt_entries(
        &self,
        mut txt_entries: &[TxtEntries],
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        MeshcopProxyInterface::r#update_txt_entries(self, txt_entries)
    }
}

impl MeshcopProxyInterface for MeshcopProxy {
    type UpdateTxtEntriesResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#update_txt_entries(
        &self,
        mut txt_entries: &[TxtEntries],
    ) -> Self::UpdateTxtEntriesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x358d4d9593140bed,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<MeshcopUpdateTxtEntriesRequest, ()>(
            (txt_entries,),
            0x358d4d9593140bed,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for MeshcopRequestStream {
    type Protocol = MeshcopMarker;
    type ControlHandle = MeshcopControlHandle;

    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 {
        MeshcopControlHandle { 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 MeshcopRequestStream {
    type Item = Result<MeshcopRequest, 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 MeshcopRequestStream 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 {
                    0x358d4d9593140bed => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MeshcopUpdateTxtEntriesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MeshcopUpdateTxtEntriesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MeshcopControlHandle { inner: this.inner.clone() };
                        Ok(MeshcopRequest::UpdateTxtEntries {
                            txt_entries: req.txt_entries,

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

/// Methods associated with the Mesh Commissioning Protocol (Meshcop).
#[derive(Debug)]
pub enum MeshcopRequest {
    /// Updates the TXT record information associated with the Meshcop border
    /// agent DNS-SD entry. This allows additional information about the
    /// device to be discoverable on the local network when acting as a
    /// border agent.
    ///
    /// Functionally equivalent to `ot-br-posix`'s
    /// [`UpdateVendorMeshCopTxtEntries`][1].
    ///
    /// Typically, the following keys are updated:
    ///
    /// * `vn`: Vendor Name
    /// * `mn`: Model Name
    /// * `vo`: Vendor OUI
    /// * `vd`/`vcd`: Vendor-specific Data
    ///
    /// See table 8-4 in section 8.4.1.1.2 of the Thread 1.2 specification for
    /// a detailed explanation of all the keys and their values.
    ///
    /// Any error that prevents the operation from completing successfully
    /// (such as being provided with invalid keys) will result in the
    /// protocol being closed.
    ///
    /// [1]: https://github.com/openthread/ot-br-posix/blob/0b5c6e1ecb8152ef6cea57c09b8a37a020fc4d6f/src/dbus/server/introspect.xml#L196-L210
    UpdateTxtEntries { txt_entries: Vec<TxtEntries>, responder: MeshcopUpdateTxtEntriesResponder },
}

impl MeshcopRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_update_txt_entries(
        self,
    ) -> Option<(Vec<TxtEntries>, MeshcopUpdateTxtEntriesResponder)> {
        if let MeshcopRequest::UpdateTxtEntries { txt_entries, responder } = self {
            Some((txt_entries, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x358d4d9593140bed,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for MeshcopConnectorMarker {
    type Proxy = MeshcopConnectorProxy;
    type RequestStream = MeshcopConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = MeshcopConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.lowpan.thread.MeshcopConnector";
}
impl fidl::endpoints::DiscoverableProtocolMarker for MeshcopConnectorMarker {}

pub trait MeshcopConnectorProxyInterface: Send + Sync {
    fn r#connect(
        &self,
        name: &str,
        server_end: fidl::endpoints::ServerEnd<MeshcopMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct MeshcopConnectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for MeshcopConnectorSynchronousProxy {
    type Proxy = MeshcopConnectorProxy;
    type Protocol = MeshcopConnectorMarker;

    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 MeshcopConnectorSynchronousProxy {
    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<MeshcopConnectorEvent, fidl::Error> {
        MeshcopConnectorEvent::decode(
            self.client.wait_for_event::<MeshcopConnectorMarker>(deadline)?,
        )
    }

    /// Connects to the [`Meshcop`] protocol on the
    /// named LoWPAN interface.
    ///
    /// The name of the interface can be learned by calling
    /// [`fuchsia.lowpan/Lookup.GetDevices`].
    ///
    /// If there is an error in processing this request
    /// the given channel is closed and an epitaph code used
    /// to describe the reason for the failure:
    ///
    /// * `ZX_ERR_INVALID_ARGUMENT`: The given interface name
    ///   was not formatted correctly or otherwise invalid.
    /// * `ZX_ERR_NOT_FOUND`: No interface was found with the
    ///   given name.
    /// * `ZX_ERR_NOT_SUPPORTED`: The interface exists but
    ///   does not support this protocol.
    pub fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<MeshcopMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<MeshcopConnectorConnectRequest>(
            (name, server_end),
            0x53f87536b40ad6fb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for MeshcopConnectorProxy {
    type Protocol = MeshcopConnectorMarker;

    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 MeshcopConnectorProxy {
    /// Create a new Proxy for fuchsia.lowpan.thread/MeshcopConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <MeshcopConnectorMarker 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) -> MeshcopConnectorEventStream {
        MeshcopConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connects to the [`Meshcop`] protocol on the
    /// named LoWPAN interface.
    ///
    /// The name of the interface can be learned by calling
    /// [`fuchsia.lowpan/Lookup.GetDevices`].
    ///
    /// If there is an error in processing this request
    /// the given channel is closed and an epitaph code used
    /// to describe the reason for the failure:
    ///
    /// * `ZX_ERR_INVALID_ARGUMENT`: The given interface name
    ///   was not formatted correctly or otherwise invalid.
    /// * `ZX_ERR_NOT_FOUND`: No interface was found with the
    ///   given name.
    /// * `ZX_ERR_NOT_SUPPORTED`: The interface exists but
    ///   does not support this protocol.
    pub fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<MeshcopMarker>,
    ) -> Result<(), fidl::Error> {
        MeshcopConnectorProxyInterface::r#connect(self, name, server_end)
    }
}

impl MeshcopConnectorProxyInterface for MeshcopConnectorProxy {
    fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<MeshcopMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<MeshcopConnectorConnectRequest>(
            (name, server_end),
            0x53f87536b40ad6fb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for MeshcopConnectorRequestStream {
    type Protocol = MeshcopConnectorMarker;
    type ControlHandle = MeshcopConnectorControlHandle;

    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 {
        MeshcopConnectorControlHandle { 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 MeshcopConnectorRequestStream {
    type Item = Result<MeshcopConnectorRequest, 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 MeshcopConnectorRequestStream 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 {
                    0x53f87536b40ad6fb => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            MeshcopConnectorConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MeshcopConnectorConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            MeshcopConnectorControlHandle { inner: this.inner.clone() };
                        Ok(MeshcopConnectorRequest::Connect {
                            name: req.name,
                            server_end: req.server_end,

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

/// Protocol for connecting to [`Meshcop`] on a LoWPAN device.
#[derive(Debug)]
pub enum MeshcopConnectorRequest {
    /// Connects to the [`Meshcop`] protocol on the
    /// named LoWPAN interface.
    ///
    /// The name of the interface can be learned by calling
    /// [`fuchsia.lowpan/Lookup.GetDevices`].
    ///
    /// If there is an error in processing this request
    /// the given channel is closed and an epitaph code used
    /// to describe the reason for the failure:
    ///
    /// * `ZX_ERR_INVALID_ARGUMENT`: The given interface name
    ///   was not formatted correctly or otherwise invalid.
    /// * `ZX_ERR_NOT_FOUND`: No interface was found with the
    ///   given name.
    /// * `ZX_ERR_NOT_SUPPORTED`: The interface exists but
    ///   does not support this protocol.
    Connect {
        name: String,
        server_end: fidl::endpoints::ServerEnd<MeshcopMarker>,
        control_handle: MeshcopConnectorControlHandle,
    },
}

impl MeshcopConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(String, fidl::endpoints::ServerEnd<MeshcopMarker>, MeshcopConnectorControlHandle)>
    {
        if let MeshcopConnectorRequest::Connect { name, server_end, control_handle } = self {
            Some((name, server_end, control_handle))
        } else {
            None
        }
    }

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ThreadCapabilitiesMarker {
    type Proxy = ThreadCapabilitiesProxy;
    type RequestStream = ThreadCapabilitiesRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ThreadCapabilitiesSynchronousProxy;

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

pub trait ThreadCapabilitiesProxyInterface: Send + Sync {
    type GetCapabilitiesResponseFut: std::future::Future<Output = Result<Capabilities, fidl::Error>>
        + Send;
    fn r#get_capabilities(&self) -> Self::GetCapabilitiesResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ThreadCapabilitiesSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ThreadCapabilitiesSynchronousProxy {
    type Proxy = ThreadCapabilitiesProxy;
    type Protocol = ThreadCapabilitiesMarker;

    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 ThreadCapabilitiesSynchronousProxy {
    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<ThreadCapabilitiesEvent, fidl::Error> {
        ThreadCapabilitiesEvent::decode(
            self.client.wait_for_event::<ThreadCapabilitiesMarker>(deadline)?,
        )
    }

    /// Returns the current capabilities of Openthread for this interface.
    ///
    /// capabilities is not expected to change for the lifetime of the
    /// interface.
    pub fn r#get_capabilities(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Capabilities, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            ThreadCapabilitiesGetCapabilitiesResponse,
            ThreadCapabilitiesMarker,
        >(
            (),
            0x5a0823ac35f2d425,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.capabilities)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ThreadCapabilitiesProxy {
    type Protocol = ThreadCapabilitiesMarker;

    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 ThreadCapabilitiesProxy {
    /// Create a new Proxy for fuchsia.lowpan.thread/ThreadCapabilities.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <ThreadCapabilitiesMarker 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) -> ThreadCapabilitiesEventStream {
        ThreadCapabilitiesEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns the current capabilities of Openthread for this interface.
    ///
    /// capabilities is not expected to change for the lifetime of the
    /// interface.
    pub fn r#get_capabilities(
        &self,
    ) -> fidl::client::QueryResponseFut<Capabilities, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        ThreadCapabilitiesProxyInterface::r#get_capabilities(self)
    }
}

impl ThreadCapabilitiesProxyInterface for ThreadCapabilitiesProxy {
    type GetCapabilitiesResponseFut =
        fidl::client::QueryResponseFut<Capabilities, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_capabilities(&self) -> Self::GetCapabilitiesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Capabilities, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ThreadCapabilitiesGetCapabilitiesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5a0823ac35f2d425,
            >(_buf?)?;
            Ok(_response.capabilities)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Capabilities>(
            (),
            0x5a0823ac35f2d425,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ThreadCapabilitiesRequestStream {
    type Protocol = ThreadCapabilitiesMarker;
    type ControlHandle = ThreadCapabilitiesControlHandle;

    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 {
        ThreadCapabilitiesControlHandle { 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 ThreadCapabilitiesRequestStream {
    type Item = Result<ThreadCapabilitiesRequest, 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 ThreadCapabilitiesRequestStream 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 {
                0x5a0823ac35f2d425 => {
                    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 = ThreadCapabilitiesControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ThreadCapabilitiesRequest::GetCapabilities {
                        responder: ThreadCapabilitiesGetCapabilitiesResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <ThreadCapabilitiesMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Protocol for retrieving supported capabilities of the thread stack.
#[derive(Debug)]
pub enum ThreadCapabilitiesRequest {
    /// Returns the current capabilities of Openthread for this interface.
    ///
    /// capabilities is not expected to change for the lifetime of the
    /// interface.
    GetCapabilities { responder: ThreadCapabilitiesGetCapabilitiesResponder },
}

impl ThreadCapabilitiesRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_capabilities(self) -> Option<(ThreadCapabilitiesGetCapabilitiesResponder)> {
        if let ThreadCapabilitiesRequest::GetCapabilities { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

    fn send_raw(&self, mut capabilities: &Capabilities) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ThreadCapabilitiesGetCapabilitiesResponse>(
            (capabilities,),
            self.tx_id,
            0x5a0823ac35f2d425,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CapabilitiesConnectorConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<32>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                server_end: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ThreadCapabilitiesMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DatasetConnectorConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<32>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                server_end: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DatasetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for EpskcConnectorConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<32>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                server_end: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<EpskcMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FeatureConnectorConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<32>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                server_end: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FeatureMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for MeshcopConnectorConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(
                    fidl::encoding::BoundedString<32>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                server_end: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MeshcopMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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