fidl_fuchsia_lowpan_experimental/

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

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

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

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

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

#[derive(Debug, PartialEq)]
pub struct DeviceExtraFormNetworkRequest {
    pub params: fidl_fuchsia_lowpan_device::ProvisioningParams,
    pub progress: fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct DeviceExtraJoinNetworkRequest {
    pub params: JoinParams,
    pub progress: fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct DeviceExtraStartNetworkScanRequest {
    pub params: NetworkScanParameters,
    pub stream: fidl::endpoints::ServerEnd<BeaconInfoStreamMarker>,
}

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for BeaconInfoStreamMarker {
    type Proxy = BeaconInfoStreamProxy;
    type RequestStream = BeaconInfoStreamRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BeaconInfoStreamSynchronousProxy;

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

pub trait BeaconInfoStreamProxyInterface: Send + Sync {
    type NextResponseFut: std::future::Future<Output = Result<Vec<BeaconInfo>, fidl::Error>> + Send;
    fn r#next(&self) -> Self::NextResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BeaconInfoStreamSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BeaconInfoStreamSynchronousProxy {
    type Proxy = BeaconInfoStreamProxy;
    type Protocol = BeaconInfoStreamMarker;

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

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

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

    /// Called to fetch the next set of received beacons.
    ///
    /// The last set will have zero items. Once all received
    /// beacons have been returned, this channel will close.
    pub fn r#next(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<BeaconInfo>, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, BeaconInfoStreamNextResponse>(
                (),
                0x367a557363a340b6,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.beacons)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for BeaconInfoStreamProxy {
    type Protocol = BeaconInfoStreamMarker;

    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 BeaconInfoStreamProxy {
    /// Create a new Proxy for fuchsia.lowpan.experimental/BeaconInfoStream.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <BeaconInfoStreamMarker 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) -> BeaconInfoStreamEventStream {
        BeaconInfoStreamEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Called to fetch the next set of received beacons.
    ///
    /// The last set will have zero items. Once all received
    /// beacons have been returned, this channel will close.
    pub fn r#next(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<BeaconInfo>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BeaconInfoStreamProxyInterface::r#next(self)
    }
}

impl BeaconInfoStreamProxyInterface for BeaconInfoStreamProxy {
    type NextResponseFut = fidl::client::QueryResponseFut<
        Vec<BeaconInfo>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#next(&self) -> Self::NextResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<BeaconInfo>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                BeaconInfoStreamNextResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x367a557363a340b6,
            >(_buf?)?;
            Ok(_response.beacons)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<BeaconInfo>>(
            (),
            0x367a557363a340b6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for BeaconInfoStreamRequestStream {
    type Protocol = BeaconInfoStreamMarker;
    type ControlHandle = BeaconInfoStreamControlHandle;

    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 {
        BeaconInfoStreamControlHandle { 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 BeaconInfoStreamRequestStream {
    type Item = Result<BeaconInfoStreamRequest, 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 BeaconInfoStreamRequestStream 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 {
                    0x367a557363a340b6 => {
                        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 =
                            BeaconInfoStreamControlHandle { inner: this.inner.clone() };
                        Ok(BeaconInfoStreamRequest::Next {
                            responder: BeaconInfoStreamNextResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <BeaconInfoStreamMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Protocol for returning the results of a network scan operation.
///
/// Closing the client end of an instance of this protocol will effectively
/// cancel the scan operation.
#[derive(Debug)]
pub enum BeaconInfoStreamRequest {
    /// Called to fetch the next set of received beacons.
    ///
    /// The last set will have zero items. Once all received
    /// beacons have been returned, this channel will close.
    Next { responder: BeaconInfoStreamNextResponder },
}

impl BeaconInfoStreamRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_next(self) -> Option<(BeaconInfoStreamNextResponder)> {
        if let BeaconInfoStreamRequest::Next { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

    fn send_raw(&self, mut beacons: &[BeaconInfo]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<BeaconInfoStreamNextResponse>(
            (beacons,),
            self.tx_id,
            0x367a557363a340b6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

pub trait DeviceProxyInterface: Send + Sync {
    type GetSupportedChannelsResponseFut: std::future::Future<Output = Result<Vec<ChannelInfo>, fidl::Error>>
        + Send;
    fn r#get_supported_channels(&self) -> Self::GetSupportedChannelsResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DeviceSynchronousProxy {
    client: fidl::client::sync::Client,
}

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

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

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

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

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

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

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

    /// Returns a vector of information about the
    /// channels supported by this interface.
    pub fn r#get_supported_channels(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<ChannelInfo>, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, DeviceGetSupportedChannelsResponse>(
                (),
                0x2d8b969a9bd70f23,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.channels_info)
    }
}

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

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

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

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

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

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

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

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

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

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

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

    /// Returns a vector of information about the
    /// channels supported by this interface.
    pub fn r#get_supported_channels(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<ChannelInfo>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceProxyInterface::r#get_supported_channels(self)
    }
}

impl DeviceProxyInterface for DeviceProxy {
    type GetSupportedChannelsResponseFut = fidl::client::QueryResponseFut<
        Vec<ChannelInfo>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_supported_channels(&self) -> Self::GetSupportedChannelsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<ChannelInfo>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceGetSupportedChannelsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2d8b969a9bd70f23,
            >(_buf?)?;
            Ok(_response.channels_info)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<ChannelInfo>>(
            (),
            0x2d8b969a9bd70f23,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x2d8b969a9bd70f23 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRequest::GetSupportedChannels {
                            responder: DeviceGetSupportedChannelsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DeviceMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// LoWPAN Device Protocol, Experimental Methods.
///
/// This protocol provides clients with a way to control and
/// monitor the device.
///
/// Note that aspects of the device that deal with PII must
/// be monitored and controlled via the [`DeviceExtra`] protocol.
#[derive(Debug)]
pub enum DeviceRequest {
    /// Returns a vector of information about the
    /// channels supported by this interface.
    GetSupportedChannels { responder: DeviceGetSupportedChannelsResponder },
}

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

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

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

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

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

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

impl DeviceControlHandle {}

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

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

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

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

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

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

    fn send_raw(&self, mut channels_info: &[ChannelInfo]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceGetSupportedChannelsResponse>(
            (channels_info,),
            self.tx_id,
            0x2d8b969a9bd70f23,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for DeviceConnectorMarker {
    type Proxy = DeviceConnectorProxy;
    type RequestStream = DeviceConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DeviceConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.lowpan.experimental.DeviceConnector";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DeviceConnectorMarker {}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DeviceConnectorSynchronousProxy {
    type Proxy = DeviceConnectorProxy;
    type Protocol = DeviceConnectorMarker;

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

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

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

    /// Connects to the [`Device`] 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<DeviceMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceConnectorConnectRequest>(
            (name, server_end),
            0x296896c9304836cd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DeviceConnectorProxy {
    type Protocol = DeviceConnectorMarker;

    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 DeviceConnectorProxy {
    /// Create a new Proxy for fuchsia.lowpan.experimental/DeviceConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DeviceConnectorMarker 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) -> DeviceConnectorEventStream {
        DeviceConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connects to the [`Device`] 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<DeviceMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceConnectorProxyInterface::r#connect(self, name, server_end)
    }
}

impl DeviceConnectorProxyInterface for DeviceConnectorProxy {
    fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<DeviceMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceConnectorConnectRequest>(
            (name, server_end),
            0x296896c9304836cd,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DeviceConnectorRequestStream {
    type Protocol = DeviceConnectorMarker;
    type ControlHandle = DeviceConnectorControlHandle;

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

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

/// Protocol for connecting to [`Device`] on a LoWPAN
/// interface.
#[derive(Debug)]
pub enum DeviceConnectorRequest {
    /// Connects to the [`Device`] 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<DeviceMarker>,
        control_handle: DeviceConnectorControlHandle,
    },
}

impl DeviceConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(String, fidl::endpoints::ServerEnd<DeviceMarker>, DeviceConnectorControlHandle)>
    {
        if let DeviceConnectorRequest::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 {
            DeviceConnectorRequest::Connect { .. } => "connect",
        }
    }
}

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

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

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

impl fidl::endpoints::ProtocolMarker for DeviceExtraMarker {
    type Proxy = DeviceExtraProxy;
    type RequestStream = DeviceExtraRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DeviceExtraSynchronousProxy;

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

pub trait DeviceExtraProxyInterface: Send + Sync {
    fn r#form_network(
        &self,
        params: &fidl_fuchsia_lowpan_device::ProvisioningParams,
        progress: fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#join_network(
        &self,
        params: &JoinParams,
        progress: fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#start_network_scan(
        &self,
        params: &NetworkScanParameters,
        stream: fidl::endpoints::ServerEnd<BeaconInfoStreamMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DeviceExtraSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DeviceExtraSynchronousProxy {
    type Proxy = DeviceExtraProxy;
    type Protocol = DeviceExtraMarker;

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

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

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

    /// Forms a new network with the given provisioning parameters.
    ///
    /// Any unspecified fields that are required by the underlying
    /// device or network type will assigned with default values.
    /// If the credential is unspecified, a random one will be
    /// generated automatically.
    ///
    /// This method will cause the device to leave any previously
    /// provisioned network.
    ///
    /// Calling this method while the device is not active will
    /// implicitly make the device active.
    ///
    /// Upon success, the device will be active and provisioned
    /// for the newly created network.
    ///
    /// The progress of the operation can be monitored via
    /// the `ProvisioningMonitor` protocol instance. The operation
    /// may be cancelled by closing the `ProvisioningMonitor`.
    ///
    /// Calling this method will cause any current form, join, or
    /// commission operation to be canceled.
    pub fn r#form_network(
        &self,
        mut params: &fidl_fuchsia_lowpan_device::ProvisioningParams,
        mut progress: fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceExtraFormNetworkRequest>(
            (params, progress),
            0x6a8135f84bfc90e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Attempts to join a pre-existing nearby network
    /// with the given provisioning parameters or joiner parameters.
    ///
    /// In-band commissioning is supported.
    ///
    /// Upon success, the device will be active and provisioned
    /// for the newly created network.
    ///
    /// The progress of the operation can be monitored via
    /// the `ProvisioningMonitor` protocol instance. The operation
    /// may be cancelled by closing the `ProvisioningMonitor`.
    ///
    /// Calling this method will cause any current form, join, or
    /// commission operation to be canceled.
    pub fn r#join_network(
        &self,
        mut params: &JoinParams,
        mut progress: fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceExtraJoinNetworkRequest>(
            (params, progress),
            0x3ea583bab79f81c0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Starts an active network scan operation.
    ///
    /// This scan is used to identify other nearby networks in order
    /// to identify channels that should be avoided.
    ///
    /// The scan operation may be cancelled by closing the stream protocol.
    ///
    /// If a scan is started while another scan is in progress,
    /// the previous scan is allowed to complete before
    /// the new scan executes and starts returning results.
    ///
    /// All scans should be expected to completely occupy the
    /// LoWPAN device while it is in progress, preventing other operations
    /// from completing until the scan has completed. Additionally, all
    /// network packets should be expected to be dropped while a scan is
    /// in progress.
    ///
    /// A [`BeaconInfoStream`] instance could be used to expose coarse
    /// location information.
    pub fn r#start_network_scan(
        &self,
        mut params: &NetworkScanParameters,
        mut stream: fidl::endpoints::ServerEnd<BeaconInfoStreamMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceExtraStartNetworkScanRequest>(
            (params, stream),
            0x6288c73b79188b40,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DeviceExtraProxy {
    type Protocol = DeviceExtraMarker;

    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 DeviceExtraProxy {
    /// Create a new Proxy for fuchsia.lowpan.experimental/DeviceExtra.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DeviceExtraMarker 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) -> DeviceExtraEventStream {
        DeviceExtraEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Forms a new network with the given provisioning parameters.
    ///
    /// Any unspecified fields that are required by the underlying
    /// device or network type will assigned with default values.
    /// If the credential is unspecified, a random one will be
    /// generated automatically.
    ///
    /// This method will cause the device to leave any previously
    /// provisioned network.
    ///
    /// Calling this method while the device is not active will
    /// implicitly make the device active.
    ///
    /// Upon success, the device will be active and provisioned
    /// for the newly created network.
    ///
    /// The progress of the operation can be monitored via
    /// the `ProvisioningMonitor` protocol instance. The operation
    /// may be cancelled by closing the `ProvisioningMonitor`.
    ///
    /// Calling this method will cause any current form, join, or
    /// commission operation to be canceled.
    pub fn r#form_network(
        &self,
        mut params: &fidl_fuchsia_lowpan_device::ProvisioningParams,
        mut progress: fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceExtraProxyInterface::r#form_network(self, params, progress)
    }

    /// Attempts to join a pre-existing nearby network
    /// with the given provisioning parameters or joiner parameters.
    ///
    /// In-band commissioning is supported.
    ///
    /// Upon success, the device will be active and provisioned
    /// for the newly created network.
    ///
    /// The progress of the operation can be monitored via
    /// the `ProvisioningMonitor` protocol instance. The operation
    /// may be cancelled by closing the `ProvisioningMonitor`.
    ///
    /// Calling this method will cause any current form, join, or
    /// commission operation to be canceled.
    pub fn r#join_network(
        &self,
        mut params: &JoinParams,
        mut progress: fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceExtraProxyInterface::r#join_network(self, params, progress)
    }

    /// Starts an active network scan operation.
    ///
    /// This scan is used to identify other nearby networks in order
    /// to identify channels that should be avoided.
    ///
    /// The scan operation may be cancelled by closing the stream protocol.
    ///
    /// If a scan is started while another scan is in progress,
    /// the previous scan is allowed to complete before
    /// the new scan executes and starts returning results.
    ///
    /// All scans should be expected to completely occupy the
    /// LoWPAN device while it is in progress, preventing other operations
    /// from completing until the scan has completed. Additionally, all
    /// network packets should be expected to be dropped while a scan is
    /// in progress.
    ///
    /// A [`BeaconInfoStream`] instance could be used to expose coarse
    /// location information.
    pub fn r#start_network_scan(
        &self,
        mut params: &NetworkScanParameters,
        mut stream: fidl::endpoints::ServerEnd<BeaconInfoStreamMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceExtraProxyInterface::r#start_network_scan(self, params, stream)
    }
}

impl DeviceExtraProxyInterface for DeviceExtraProxy {
    fn r#form_network(
        &self,
        mut params: &fidl_fuchsia_lowpan_device::ProvisioningParams,
        mut progress: fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceExtraFormNetworkRequest>(
            (params, progress),
            0x6a8135f84bfc90e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#join_network(
        &self,
        mut params: &JoinParams,
        mut progress: fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceExtraJoinNetworkRequest>(
            (params, progress),
            0x3ea583bab79f81c0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#start_network_scan(
        &self,
        mut params: &NetworkScanParameters,
        mut stream: fidl::endpoints::ServerEnd<BeaconInfoStreamMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceExtraStartNetworkScanRequest>(
            (params, stream),
            0x6288c73b79188b40,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DeviceExtraRequestStream {
    type Protocol = DeviceExtraMarker;
    type ControlHandle = DeviceExtraControlHandle;

    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 {
        DeviceExtraControlHandle { 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 DeviceExtraRequestStream {
    type Item = Result<DeviceExtraRequest, 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 DeviceExtraRequestStream 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 {
                    0x6a8135f84bfc90e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceExtraFormNetworkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceExtraFormNetworkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceExtraControlHandle { inner: this.inner.clone() };
                        Ok(DeviceExtraRequest::FormNetwork {
                            params: req.params,
                            progress: req.progress,

                            control_handle,
                        })
                    }
                    0x3ea583bab79f81c0 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceExtraJoinNetworkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceExtraJoinNetworkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceExtraControlHandle { inner: this.inner.clone() };
                        Ok(DeviceExtraRequest::JoinNetwork {
                            params: req.params,
                            progress: req.progress,

                            control_handle,
                        })
                    }
                    0x6288c73b79188b40 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceExtraStartNetworkScanRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceExtraStartNetworkScanRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceExtraControlHandle { inner: this.inner.clone() };
                        Ok(DeviceExtraRequest::StartNetworkScan {
                            params: req.params,
                            stream: req.stream,

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

/// LoWPAN Device "Extra" Protocol, Experimental Methods.
///
/// This protocol provides clients with a way to control and
/// monitor aspects of the LoWPAN device that can, either
/// directly or indirectly, leak PII or cryptographic keys.
#[derive(Debug)]
pub enum DeviceExtraRequest {
    /// Forms a new network with the given provisioning parameters.
    ///
    /// Any unspecified fields that are required by the underlying
    /// device or network type will assigned with default values.
    /// If the credential is unspecified, a random one will be
    /// generated automatically.
    ///
    /// This method will cause the device to leave any previously
    /// provisioned network.
    ///
    /// Calling this method while the device is not active will
    /// implicitly make the device active.
    ///
    /// Upon success, the device will be active and provisioned
    /// for the newly created network.
    ///
    /// The progress of the operation can be monitored via
    /// the `ProvisioningMonitor` protocol instance. The operation
    /// may be cancelled by closing the `ProvisioningMonitor`.
    ///
    /// Calling this method will cause any current form, join, or
    /// commission operation to be canceled.
    FormNetwork {
        params: fidl_fuchsia_lowpan_device::ProvisioningParams,
        progress: fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>,
        control_handle: DeviceExtraControlHandle,
    },
    /// Attempts to join a pre-existing nearby network
    /// with the given provisioning parameters or joiner parameters.
    ///
    /// In-band commissioning is supported.
    ///
    /// Upon success, the device will be active and provisioned
    /// for the newly created network.
    ///
    /// The progress of the operation can be monitored via
    /// the `ProvisioningMonitor` protocol instance. The operation
    /// may be cancelled by closing the `ProvisioningMonitor`.
    ///
    /// Calling this method will cause any current form, join, or
    /// commission operation to be canceled.
    JoinNetwork {
        params: JoinParams,
        progress: fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>,
        control_handle: DeviceExtraControlHandle,
    },
    /// Starts an active network scan operation.
    ///
    /// This scan is used to identify other nearby networks in order
    /// to identify channels that should be avoided.
    ///
    /// The scan operation may be cancelled by closing the stream protocol.
    ///
    /// If a scan is started while another scan is in progress,
    /// the previous scan is allowed to complete before
    /// the new scan executes and starts returning results.
    ///
    /// All scans should be expected to completely occupy the
    /// LoWPAN device while it is in progress, preventing other operations
    /// from completing until the scan has completed. Additionally, all
    /// network packets should be expected to be dropped while a scan is
    /// in progress.
    ///
    /// A [`BeaconInfoStream`] instance could be used to expose coarse
    /// location information.
    StartNetworkScan {
        params: NetworkScanParameters,
        stream: fidl::endpoints::ServerEnd<BeaconInfoStreamMarker>,
        control_handle: DeviceExtraControlHandle,
    },
}

impl DeviceExtraRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_form_network(
        self,
    ) -> Option<(
        fidl_fuchsia_lowpan_device::ProvisioningParams,
        fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>,
        DeviceExtraControlHandle,
    )> {
        if let DeviceExtraRequest::FormNetwork { params, progress, control_handle } = self {
            Some((params, progress, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_join_network(
        self,
    ) -> Option<(
        JoinParams,
        fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>,
        DeviceExtraControlHandle,
    )> {
        if let DeviceExtraRequest::JoinNetwork { params, progress, control_handle } = self {
            Some((params, progress, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start_network_scan(
        self,
    ) -> Option<(
        NetworkScanParameters,
        fidl::endpoints::ServerEnd<BeaconInfoStreamMarker>,
        DeviceExtraControlHandle,
    )> {
        if let DeviceExtraRequest::StartNetworkScan { params, stream, control_handle } = self {
            Some((params, stream, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DeviceExtraRequest::FormNetwork { .. } => "form_network",
            DeviceExtraRequest::JoinNetwork { .. } => "join_network",
            DeviceExtraRequest::StartNetworkScan { .. } => "start_network_scan",
        }
    }
}

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

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

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

impl fidl::endpoints::ProtocolMarker for DeviceExtraConnectorMarker {
    type Proxy = DeviceExtraConnectorProxy;
    type RequestStream = DeviceExtraConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DeviceExtraConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.lowpan.experimental.DeviceExtraConnector";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DeviceExtraConnectorMarker {}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DeviceExtraConnectorSynchronousProxy {
    type Proxy = DeviceExtraConnectorProxy;
    type Protocol = DeviceExtraConnectorMarker;

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

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

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

    /// Connects to the [`DeviceExtra`] 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<DeviceExtraMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceExtraConnectorConnectRequest>(
            (name, server_end),
            0x3fcb37e4226c81e9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DeviceExtraConnectorProxy {
    type Protocol = DeviceExtraConnectorMarker;

    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 DeviceExtraConnectorProxy {
    /// Create a new Proxy for fuchsia.lowpan.experimental/DeviceExtraConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <DeviceExtraConnectorMarker 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) -> DeviceExtraConnectorEventStream {
        DeviceExtraConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connects to the [`DeviceExtra`] 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<DeviceExtraMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceExtraConnectorProxyInterface::r#connect(self, name, server_end)
    }
}

impl DeviceExtraConnectorProxyInterface for DeviceExtraConnectorProxy {
    fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<DeviceExtraMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceExtraConnectorConnectRequest>(
            (name, server_end),
            0x3fcb37e4226c81e9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DeviceExtraConnectorRequestStream {
    type Protocol = DeviceExtraConnectorMarker;
    type ControlHandle = DeviceExtraConnectorControlHandle;

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

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

/// Protocol for connecting to [`DeviceExtra`] on a LoWPAN
/// interface.
#[derive(Debug)]
pub enum DeviceExtraConnectorRequest {
    /// Connects to the [`DeviceExtra`] 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<DeviceExtraMarker>,
        control_handle: DeviceExtraConnectorControlHandle,
    },
}

impl DeviceExtraConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(
        String,
        fidl::endpoints::ServerEnd<DeviceExtraMarker>,
        DeviceExtraConnectorControlHandle,
    )> {
        if let DeviceExtraConnectorRequest::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 {
            DeviceExtraConnectorRequest::Connect { .. } => "connect",
        }
    }
}

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

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

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

impl fidl::endpoints::ProtocolMarker for DeviceRouteMarker {
    type Proxy = DeviceRouteProxy;
    type RequestStream = DeviceRouteRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DeviceRouteSynchronousProxy;

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

pub trait DeviceRouteProxyInterface: Send + Sync {
    type RegisterOnMeshPrefixResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#register_on_mesh_prefix(
        &self,
        prefix: &OnMeshPrefix,
    ) -> Self::RegisterOnMeshPrefixResponseFut;
    type UnregisterOnMeshPrefixResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#unregister_on_mesh_prefix(
        &self,
        subnet: &fidl_fuchsia_net::Ipv6AddressWithPrefix,
    ) -> Self::UnregisterOnMeshPrefixResponseFut;
    type RegisterExternalRouteResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#register_external_route(
        &self,
        external_route: &ExternalRoute,
    ) -> Self::RegisterExternalRouteResponseFut;
    type UnregisterExternalRouteResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#unregister_external_route(
        &self,
        subnet: &fidl_fuchsia_net::Ipv6AddressWithPrefix,
    ) -> Self::UnregisterExternalRouteResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DeviceRouteSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DeviceRouteSynchronousProxy {
    type Proxy = DeviceRouteProxy;
    type Protocol = DeviceRouteMarker;

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

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

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

    /// Registers an on-mesh prefix to be advertised on the
    /// current network.
    ///
    /// Subsequent calls with the same value for the `subnet` field will
    /// update the properties associated with that on-mesh prefix.
    ///
    /// These changes persist like adding an IP address would,
    /// and will stick around until explicitly removed or
    /// the interface component is reset/restarted.
    ///
    /// If the given `OnMeshPrefix` structure is invalid for some reason
    /// (missing required fields, invalid values, etc), the channel will be
    /// closed with the epitaph `ZX_ERR_INVALID_ARGS`.
    ///
    /// If registering a new on-mesh prefix and the maximum number of
    /// on-mesh prefixes has already been registered, this channel will
    /// be closed with the epitaph `ZX_ERR_NO_RESOURCES`.
    pub fn r#register_on_mesh_prefix(
        &self,
        mut prefix: &OnMeshPrefix,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<DeviceRouteRegisterOnMeshPrefixRequest, fidl::encoding::EmptyPayload>(
                (prefix,),
                0x2c4135231eb97f61,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Unregisters any on-mesh prefix that was previously registered with
    /// `RegisterOnMeshPrefix`.  It returns once the on-mesh prefix has
    /// been removed locally.
    ///
    /// If the given mesh prefix was not previously registered,
    /// no action is taken.
    pub fn r#unregister_on_mesh_prefix(
        &self,
        mut subnet: &fidl_fuchsia_net::Ipv6AddressWithPrefix,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<DeviceRouteUnregisterOnMeshPrefixRequest, fidl::encoding::EmptyPayload>(
                (subnet,),
                0x82d5184028b797f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Registers an external route to be advertised on the
    /// current network.
    ///
    /// Subsequent calls with the same value for the `subnet` field will
    /// update the properties associated with that route.
    ///
    /// These changes persist like adding an IP address would,
    /// and will stick around until explicitly removed or
    /// the interface component is reset/restarted.
    ///
    /// If the given `ExternalRoute` structure is invalid for some reason
    /// (missing required fields, invalid values, etc), the channel will be
    /// closed with the epitaph `ZX_ERR_INVALID_ARGUMENT`.
    ///
    /// If registering a new external route and the maximum number of
    /// external routes has already been registered, this channel will
    /// be closed with the epitaph `ZX_ERR_NO_RESOURCES`.
    pub fn r#register_external_route(
        &self,
        mut external_route: &ExternalRoute,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<DeviceRouteRegisterExternalRouteRequest, fidl::encoding::EmptyPayload>(
                (external_route,),
                0x75f70f0fc34a5a73,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Unregisters any external route that was previously registered with
    /// `RegisterExternalRoute`. It returns once the external route has
    /// been removed locally.
    ///
    /// If the given external route was not previously registered,
    /// no action is taken.
    pub fn r#unregister_external_route(
        &self,
        mut subnet: &fidl_fuchsia_net::Ipv6AddressWithPrefix,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<DeviceRouteUnregisterExternalRouteRequest, fidl::encoding::EmptyPayload>(
                (subnet,),
                0x3769be353b1d7088,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DeviceRouteProxy {
    type Protocol = DeviceRouteMarker;

    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 DeviceRouteProxy {
    /// Create a new Proxy for fuchsia.lowpan.experimental/DeviceRoute.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DeviceRouteMarker 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) -> DeviceRouteEventStream {
        DeviceRouteEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Registers an on-mesh prefix to be advertised on the
    /// current network.
    ///
    /// Subsequent calls with the same value for the `subnet` field will
    /// update the properties associated with that on-mesh prefix.
    ///
    /// These changes persist like adding an IP address would,
    /// and will stick around until explicitly removed or
    /// the interface component is reset/restarted.
    ///
    /// If the given `OnMeshPrefix` structure is invalid for some reason
    /// (missing required fields, invalid values, etc), the channel will be
    /// closed with the epitaph `ZX_ERR_INVALID_ARGS`.
    ///
    /// If registering a new on-mesh prefix and the maximum number of
    /// on-mesh prefixes has already been registered, this channel will
    /// be closed with the epitaph `ZX_ERR_NO_RESOURCES`.
    pub fn r#register_on_mesh_prefix(
        &self,
        mut prefix: &OnMeshPrefix,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        DeviceRouteProxyInterface::r#register_on_mesh_prefix(self, prefix)
    }

    /// Unregisters any on-mesh prefix that was previously registered with
    /// `RegisterOnMeshPrefix`.  It returns once the on-mesh prefix has
    /// been removed locally.
    ///
    /// If the given mesh prefix was not previously registered,
    /// no action is taken.
    pub fn r#unregister_on_mesh_prefix(
        &self,
        mut subnet: &fidl_fuchsia_net::Ipv6AddressWithPrefix,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        DeviceRouteProxyInterface::r#unregister_on_mesh_prefix(self, subnet)
    }

    /// Registers an external route to be advertised on the
    /// current network.
    ///
    /// Subsequent calls with the same value for the `subnet` field will
    /// update the properties associated with that route.
    ///
    /// These changes persist like adding an IP address would,
    /// and will stick around until explicitly removed or
    /// the interface component is reset/restarted.
    ///
    /// If the given `ExternalRoute` structure is invalid for some reason
    /// (missing required fields, invalid values, etc), the channel will be
    /// closed with the epitaph `ZX_ERR_INVALID_ARGUMENT`.
    ///
    /// If registering a new external route and the maximum number of
    /// external routes has already been registered, this channel will
    /// be closed with the epitaph `ZX_ERR_NO_RESOURCES`.
    pub fn r#register_external_route(
        &self,
        mut external_route: &ExternalRoute,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        DeviceRouteProxyInterface::r#register_external_route(self, external_route)
    }

    /// Unregisters any external route that was previously registered with
    /// `RegisterExternalRoute`. It returns once the external route has
    /// been removed locally.
    ///
    /// If the given external route was not previously registered,
    /// no action is taken.
    pub fn r#unregister_external_route(
        &self,
        mut subnet: &fidl_fuchsia_net::Ipv6AddressWithPrefix,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        DeviceRouteProxyInterface::r#unregister_external_route(self, subnet)
    }
}

impl DeviceRouteProxyInterface for DeviceRouteProxy {
    type RegisterOnMeshPrefixResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#register_on_mesh_prefix(
        &self,
        mut prefix: &OnMeshPrefix,
    ) -> Self::RegisterOnMeshPrefixResponseFut {
        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,
                0x2c4135231eb97f61,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<DeviceRouteRegisterOnMeshPrefixRequest, ()>(
            (prefix,),
            0x2c4135231eb97f61,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UnregisterOnMeshPrefixResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#unregister_on_mesh_prefix(
        &self,
        mut subnet: &fidl_fuchsia_net::Ipv6AddressWithPrefix,
    ) -> Self::UnregisterOnMeshPrefixResponseFut {
        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,
                0x82d5184028b797f,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<DeviceRouteUnregisterOnMeshPrefixRequest, ()>(
            (subnet,),
            0x82d5184028b797f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RegisterExternalRouteResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#register_external_route(
        &self,
        mut external_route: &ExternalRoute,
    ) -> Self::RegisterExternalRouteResponseFut {
        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,
                0x75f70f0fc34a5a73,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<DeviceRouteRegisterExternalRouteRequest, ()>(
            (external_route,),
            0x75f70f0fc34a5a73,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UnregisterExternalRouteResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#unregister_external_route(
        &self,
        mut subnet: &fidl_fuchsia_net::Ipv6AddressWithPrefix,
    ) -> Self::UnregisterExternalRouteResponseFut {
        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,
                0x3769be353b1d7088,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<DeviceRouteUnregisterExternalRouteRequest, ()>(
            (subnet,),
            0x3769be353b1d7088,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DeviceRouteRequestStream {
    type Protocol = DeviceRouteMarker;
    type ControlHandle = DeviceRouteControlHandle;

    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 {
        DeviceRouteControlHandle { 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 DeviceRouteRequestStream {
    type Item = Result<DeviceRouteRequest, 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 DeviceRouteRequestStream 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 {
                    0x2c4135231eb97f61 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceRouteRegisterOnMeshPrefixRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceRouteRegisterOnMeshPrefixRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceRouteControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRouteRequest::RegisterOnMeshPrefix {
                            prefix: req.prefix,

                            responder: DeviceRouteRegisterOnMeshPrefixResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x82d5184028b797f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceRouteUnregisterOnMeshPrefixRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceRouteUnregisterOnMeshPrefixRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceRouteControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRouteRequest::UnregisterOnMeshPrefix {
                            subnet: req.subnet,

                            responder: DeviceRouteUnregisterOnMeshPrefixResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x75f70f0fc34a5a73 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceRouteRegisterExternalRouteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceRouteRegisterExternalRouteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceRouteControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRouteRequest::RegisterExternalRoute {
                            external_route: req.external_route,

                            responder: DeviceRouteRegisterExternalRouteResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3769be353b1d7088 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceRouteUnregisterExternalRouteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceRouteUnregisterExternalRouteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DeviceRouteControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRouteRequest::UnregisterExternalRoute {
                            subnet: req.subnet,

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

/// LoWPAN protocol for IPv6 route and prefix management methods that
/// do not expose PII.
///
/// Note that methods that deal with PII are located in the
/// `DeviceRouteExtra` protocol.
#[derive(Debug)]
pub enum DeviceRouteRequest {
    /// Registers an on-mesh prefix to be advertised on the
    /// current network.
    ///
    /// Subsequent calls with the same value for the `subnet` field will
    /// update the properties associated with that on-mesh prefix.
    ///
    /// These changes persist like adding an IP address would,
    /// and will stick around until explicitly removed or
    /// the interface component is reset/restarted.
    ///
    /// If the given `OnMeshPrefix` structure is invalid for some reason
    /// (missing required fields, invalid values, etc), the channel will be
    /// closed with the epitaph `ZX_ERR_INVALID_ARGS`.
    ///
    /// If registering a new on-mesh prefix and the maximum number of
    /// on-mesh prefixes has already been registered, this channel will
    /// be closed with the epitaph `ZX_ERR_NO_RESOURCES`.
    RegisterOnMeshPrefix {
        prefix: OnMeshPrefix,
        responder: DeviceRouteRegisterOnMeshPrefixResponder,
    },
    /// Unregisters any on-mesh prefix that was previously registered with
    /// `RegisterOnMeshPrefix`.  It returns once the on-mesh prefix has
    /// been removed locally.
    ///
    /// If the given mesh prefix was not previously registered,
    /// no action is taken.
    UnregisterOnMeshPrefix {
        subnet: fidl_fuchsia_net::Ipv6AddressWithPrefix,
        responder: DeviceRouteUnregisterOnMeshPrefixResponder,
    },
    /// Registers an external route to be advertised on the
    /// current network.
    ///
    /// Subsequent calls with the same value for the `subnet` field will
    /// update the properties associated with that route.
    ///
    /// These changes persist like adding an IP address would,
    /// and will stick around until explicitly removed or
    /// the interface component is reset/restarted.
    ///
    /// If the given `ExternalRoute` structure is invalid for some reason
    /// (missing required fields, invalid values, etc), the channel will be
    /// closed with the epitaph `ZX_ERR_INVALID_ARGUMENT`.
    ///
    /// If registering a new external route and the maximum number of
    /// external routes has already been registered, this channel will
    /// be closed with the epitaph `ZX_ERR_NO_RESOURCES`.
    RegisterExternalRoute {
        external_route: ExternalRoute,
        responder: DeviceRouteRegisterExternalRouteResponder,
    },
    /// Unregisters any external route that was previously registered with
    /// `RegisterExternalRoute`. It returns once the external route has
    /// been removed locally.
    ///
    /// If the given external route was not previously registered,
    /// no action is taken.
    UnregisterExternalRoute {
        subnet: fidl_fuchsia_net::Ipv6AddressWithPrefix,
        responder: DeviceRouteUnregisterExternalRouteResponder,
    },
}

impl DeviceRouteRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_register_on_mesh_prefix(
        self,
    ) -> Option<(OnMeshPrefix, DeviceRouteRegisterOnMeshPrefixResponder)> {
        if let DeviceRouteRequest::RegisterOnMeshPrefix { prefix, responder } = self {
            Some((prefix, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_unregister_on_mesh_prefix(
        self,
    ) -> Option<(fidl_fuchsia_net::Ipv6AddressWithPrefix, DeviceRouteUnregisterOnMeshPrefixResponder)>
    {
        if let DeviceRouteRequest::UnregisterOnMeshPrefix { subnet, responder } = self {
            Some((subnet, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_register_external_route(
        self,
    ) -> Option<(ExternalRoute, DeviceRouteRegisterExternalRouteResponder)> {
        if let DeviceRouteRequest::RegisterExternalRoute { external_route, responder } = self {
            Some((external_route, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_unregister_external_route(
        self,
    ) -> Option<(
        fidl_fuchsia_net::Ipv6AddressWithPrefix,
        DeviceRouteUnregisterExternalRouteResponder,
    )> {
        if let DeviceRouteRequest::UnregisterExternalRoute { subnet, responder } = self {
            Some((subnet, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DeviceRouteRequest::RegisterOnMeshPrefix { .. } => "register_on_mesh_prefix",
            DeviceRouteRequest::UnregisterOnMeshPrefix { .. } => "unregister_on_mesh_prefix",
            DeviceRouteRequest::RegisterExternalRoute { .. } => "register_external_route",
            DeviceRouteRequest::UnregisterExternalRoute { .. } => "unregister_external_route",
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for DeviceRouteConnectorMarker {
    type Proxy = DeviceRouteConnectorProxy;
    type RequestStream = DeviceRouteConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DeviceRouteConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.lowpan.experimental.DeviceRouteConnector";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DeviceRouteConnectorMarker {}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DeviceRouteConnectorSynchronousProxy {
    type Proxy = DeviceRouteConnectorProxy;
    type Protocol = DeviceRouteConnectorMarker;

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

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

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

    /// Connects to the `fuchsia.lowpan.device.DeviceRoute` 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<DeviceRouteMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceRouteConnectorConnectRequest>(
            (name, server_end),
            0x19cd5fdcb971f4ac,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DeviceRouteConnectorProxy {
    type Protocol = DeviceRouteConnectorMarker;

    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 DeviceRouteConnectorProxy {
    /// Create a new Proxy for fuchsia.lowpan.experimental/DeviceRouteConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <DeviceRouteConnectorMarker 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) -> DeviceRouteConnectorEventStream {
        DeviceRouteConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connects to the `fuchsia.lowpan.device.DeviceRoute` 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<DeviceRouteMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceRouteConnectorProxyInterface::r#connect(self, name, server_end)
    }
}

impl DeviceRouteConnectorProxyInterface for DeviceRouteConnectorProxy {
    fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<DeviceRouteMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceRouteConnectorConnectRequest>(
            (name, server_end),
            0x19cd5fdcb971f4ac,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DeviceRouteConnectorRequestStream {
    type Protocol = DeviceRouteConnectorMarker;
    type ControlHandle = DeviceRouteConnectorControlHandle;

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

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

/// Protocol for connecting to `fuchsia.lowpan.device.DeviceRoute` on a LoWPAN
/// interface.
#[derive(Debug)]
pub enum DeviceRouteConnectorRequest {
    /// Connects to the `fuchsia.lowpan.device.DeviceRoute` 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<DeviceRouteMarker>,
        control_handle: DeviceRouteConnectorControlHandle,
    },
}

impl DeviceRouteConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(
        String,
        fidl::endpoints::ServerEnd<DeviceRouteMarker>,
        DeviceRouteConnectorControlHandle,
    )> {
        if let DeviceRouteConnectorRequest::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 {
            DeviceRouteConnectorRequest::Connect { .. } => "connect",
        }
    }
}

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

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

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

impl fidl::endpoints::ProtocolMarker for DeviceRouteExtraMarker {
    type Proxy = DeviceRouteExtraProxy;
    type RequestStream = DeviceRouteExtraRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DeviceRouteExtraSynchronousProxy;

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

pub trait DeviceRouteExtraProxyInterface: Send + Sync {
    type GetLocalOnMeshPrefixesResponseFut: std::future::Future<Output = Result<Vec<OnMeshPrefix>, fidl::Error>>
        + Send;
    fn r#get_local_on_mesh_prefixes(&self) -> Self::GetLocalOnMeshPrefixesResponseFut;
    type GetLocalExternalRoutesResponseFut: std::future::Future<Output = Result<Vec<ExternalRoute>, fidl::Error>>
        + Send;
    fn r#get_local_external_routes(&self) -> Self::GetLocalExternalRoutesResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DeviceRouteExtraSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DeviceRouteExtraSynchronousProxy {
    type Proxy = DeviceRouteExtraProxy;
    type Protocol = DeviceRouteExtraMarker;

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

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

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

    /// Returns a vector containing all of the locally-added on-mesh prefixes.
    ///
    /// Locally-added on-mesh prefixes are those that have been registered
    /// with a prior call to [`DeviceRoute.RegisterOnMeshPrefix`].
    pub fn r#get_local_on_mesh_prefixes(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<OnMeshPrefix>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            DeviceRouteExtraGetLocalOnMeshPrefixesResponse,
        >(
            (),
            0xf192c43311c811,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.prefixes)
    }

    /// Returns a vector containing all of the locally-added external routes.
    ///
    /// Locally-added external routes are those that have been registered
    /// with a prior call to [`DeviceRoute.RegisterExternalRoute`].
    pub fn r#get_local_external_routes(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<ExternalRoute>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            DeviceRouteExtraGetLocalExternalRoutesResponse,
        >(
            (),
            0x5a688c2e62c766a6,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.external_routes)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DeviceRouteExtraProxy {
    type Protocol = DeviceRouteExtraMarker;

    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 DeviceRouteExtraProxy {
    /// Create a new Proxy for fuchsia.lowpan.experimental/DeviceRouteExtra.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DeviceRouteExtraMarker 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) -> DeviceRouteExtraEventStream {
        DeviceRouteExtraEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns a vector containing all of the locally-added on-mesh prefixes.
    ///
    /// Locally-added on-mesh prefixes are those that have been registered
    /// with a prior call to [`DeviceRoute.RegisterOnMeshPrefix`].
    pub fn r#get_local_on_mesh_prefixes(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<OnMeshPrefix>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceRouteExtraProxyInterface::r#get_local_on_mesh_prefixes(self)
    }

    /// Returns a vector containing all of the locally-added external routes.
    ///
    /// Locally-added external routes are those that have been registered
    /// with a prior call to [`DeviceRoute.RegisterExternalRoute`].
    pub fn r#get_local_external_routes(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<ExternalRoute>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DeviceRouteExtraProxyInterface::r#get_local_external_routes(self)
    }
}

impl DeviceRouteExtraProxyInterface for DeviceRouteExtraProxy {
    type GetLocalOnMeshPrefixesResponseFut = fidl::client::QueryResponseFut<
        Vec<OnMeshPrefix>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_local_on_mesh_prefixes(&self) -> Self::GetLocalOnMeshPrefixesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<OnMeshPrefix>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceRouteExtraGetLocalOnMeshPrefixesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xf192c43311c811,
            >(_buf?)?;
            Ok(_response.prefixes)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<OnMeshPrefix>>(
            (),
            0xf192c43311c811,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetLocalExternalRoutesResponseFut = fidl::client::QueryResponseFut<
        Vec<ExternalRoute>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_local_external_routes(&self) -> Self::GetLocalExternalRoutesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<ExternalRoute>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DeviceRouteExtraGetLocalExternalRoutesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5a688c2e62c766a6,
            >(_buf?)?;
            Ok(_response.external_routes)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<ExternalRoute>>(
            (),
            0x5a688c2e62c766a6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DeviceRouteExtraRequestStream {
    type Protocol = DeviceRouteExtraMarker;
    type ControlHandle = DeviceRouteExtraControlHandle;

    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 {
        DeviceRouteExtraControlHandle { 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 DeviceRouteExtraRequestStream {
    type Item = Result<DeviceRouteExtraRequest, 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 DeviceRouteExtraRequestStream 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 {
                    0xf192c43311c811 => {
                        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 =
                            DeviceRouteExtraControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRouteExtraRequest::GetLocalOnMeshPrefixes {
                            responder: DeviceRouteExtraGetLocalOnMeshPrefixesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5a688c2e62c766a6 => {
                        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 =
                            DeviceRouteExtraControlHandle { inner: this.inner.clone() };
                        Ok(DeviceRouteExtraRequest::GetLocalExternalRoutes {
                            responder: DeviceRouteExtraGetLocalExternalRoutesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DeviceRouteExtraMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// LoWPAN protocol for IPv6 route and prefix management methods that
/// expose PII.
///
/// Note that methods that do not deal with PII are located in the
/// `DeviceRoute` protocol.
#[derive(Debug)]
pub enum DeviceRouteExtraRequest {
    /// Returns a vector containing all of the locally-added on-mesh prefixes.
    ///
    /// Locally-added on-mesh prefixes are those that have been registered
    /// with a prior call to [`DeviceRoute.RegisterOnMeshPrefix`].
    GetLocalOnMeshPrefixes { responder: DeviceRouteExtraGetLocalOnMeshPrefixesResponder },
    /// Returns a vector containing all of the locally-added external routes.
    ///
    /// Locally-added external routes are those that have been registered
    /// with a prior call to [`DeviceRoute.RegisterExternalRoute`].
    GetLocalExternalRoutes { responder: DeviceRouteExtraGetLocalExternalRoutesResponder },
}

impl DeviceRouteExtraRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_local_on_mesh_prefixes(
        self,
    ) -> Option<(DeviceRouteExtraGetLocalOnMeshPrefixesResponder)> {
        if let DeviceRouteExtraRequest::GetLocalOnMeshPrefixes { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_local_external_routes(
        self,
    ) -> Option<(DeviceRouteExtraGetLocalExternalRoutesResponder)> {
        if let DeviceRouteExtraRequest::GetLocalExternalRoutes { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DeviceRouteExtraRequest::GetLocalOnMeshPrefixes { .. } => "get_local_on_mesh_prefixes",
            DeviceRouteExtraRequest::GetLocalExternalRoutes { .. } => "get_local_external_routes",
        }
    }
}

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

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

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

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

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

    fn send_raw(&self, mut prefixes: &[OnMeshPrefix]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceRouteExtraGetLocalOnMeshPrefixesResponse>(
            (prefixes,),
            self.tx_id,
            0xf192c43311c811,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut external_routes: &[ExternalRoute]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DeviceRouteExtraGetLocalExternalRoutesResponse>(
            (external_routes,),
            self.tx_id,
            0x5a688c2e62c766a6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for DeviceRouteExtraConnectorMarker {
    type Proxy = DeviceRouteExtraConnectorProxy;
    type RequestStream = DeviceRouteExtraConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DeviceRouteExtraConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.lowpan.experimental.DeviceRouteExtraConnector";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DeviceRouteExtraConnectorMarker {}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DeviceRouteExtraConnectorSynchronousProxy {
    type Proxy = DeviceRouteExtraConnectorProxy;
    type Protocol = DeviceRouteExtraConnectorMarker;

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

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

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

    /// Connects to the [`DeviceRouteExtra`] 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<DeviceRouteExtraMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceRouteExtraConnectorConnectRequest>(
            (name, server_end),
            0x12f72df7b1348fe2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DeviceRouteExtraConnectorProxy {
    type Protocol = DeviceRouteExtraConnectorMarker;

    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 DeviceRouteExtraConnectorProxy {
    /// Create a new Proxy for fuchsia.lowpan.experimental/DeviceRouteExtraConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <DeviceRouteExtraConnectorMarker 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) -> DeviceRouteExtraConnectorEventStream {
        DeviceRouteExtraConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connects to the [`DeviceRouteExtra`] 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<DeviceRouteExtraMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceRouteExtraConnectorProxyInterface::r#connect(self, name, server_end)
    }
}

impl DeviceRouteExtraConnectorProxyInterface for DeviceRouteExtraConnectorProxy {
    fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<DeviceRouteExtraMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceRouteExtraConnectorConnectRequest>(
            (name, server_end),
            0x12f72df7b1348fe2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for DeviceRouteExtraConnectorRequestStream {
    type Protocol = DeviceRouteExtraConnectorMarker;
    type ControlHandle = DeviceRouteExtraConnectorControlHandle;

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

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

/// Protocol for connecting to [`DeviceRouteExtra`] on a LoWPAN
/// interface.
#[derive(Debug)]
pub enum DeviceRouteExtraConnectorRequest {
    /// Connects to the [`DeviceRouteExtra`] 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<DeviceRouteExtraMarker>,
        control_handle: DeviceRouteExtraConnectorControlHandle,
    },
}

impl DeviceRouteExtraConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(
        String,
        fidl::endpoints::ServerEnd<DeviceRouteExtraMarker>,
        DeviceRouteExtraConnectorControlHandle,
    )> {
        if let DeviceRouteExtraConnectorRequest::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 {
            DeviceRouteExtraConnectorRequest::Connect { .. } => "connect",
        }
    }
}

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

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

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

impl fidl::endpoints::ProtocolMarker for LegacyJoiningMarker {
    type Proxy = LegacyJoiningProxy;
    type RequestStream = LegacyJoiningRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = LegacyJoiningSynchronousProxy;

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

pub trait LegacyJoiningProxyInterface: Send + Sync {
    type MakeJoinableResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#make_joinable(&self, duration: i64, port: u16) -> Self::MakeJoinableResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct LegacyJoiningSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for LegacyJoiningSynchronousProxy {
    type Proxy = LegacyJoiningProxy;
    type Protocol = LegacyJoiningMarker;

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

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

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

    /// Makes the interface joinable for Thread devices that need to use a
    /// non-standard in-band commissioning protocol. It is not used for
    /// standard Thread commissioning.
    ///
    /// When this call returns, the interface has been made joinable if
    /// requested.
    ///
    /// Subsequent calls to this method will override previous calls.
    /// To force the interface to no longer be joinable immediately, call
    /// this method with a duration of zero seconds and a port of zero (port
    /// is ignored in this case).
    ///
    /// This method must only be called when the interface is online
    /// (Specifically, either attaching, attached, or isolated). If the
    /// interface is in any other state, the channel will be closed with
    /// `ZX_ERR_BAD_STATE`.
    ///
    /// `duration` specifies a minimum time the interface should be made
    /// joinable, relative to the time the call is received. It may be rounded
    /// up to the nearest second.
    ///
    /// `port` specifies the local port that TCP or UDP commissioning traffic
    /// will be directed to.
    pub fn r#make_joinable(
        &self,
        mut duration: i64,
        mut port: u16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<LegacyJoiningMakeJoinableRequest, fidl::encoding::EmptyPayload>(
                (duration, port),
                0x1739a6ae36d5c5aa,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for LegacyJoiningProxy {
    type Protocol = LegacyJoiningMarker;

    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 LegacyJoiningProxy {
    /// Create a new Proxy for fuchsia.lowpan.experimental/LegacyJoining.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <LegacyJoiningMarker 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) -> LegacyJoiningEventStream {
        LegacyJoiningEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Makes the interface joinable for Thread devices that need to use a
    /// non-standard in-band commissioning protocol. It is not used for
    /// standard Thread commissioning.
    ///
    /// When this call returns, the interface has been made joinable if
    /// requested.
    ///
    /// Subsequent calls to this method will override previous calls.
    /// To force the interface to no longer be joinable immediately, call
    /// this method with a duration of zero seconds and a port of zero (port
    /// is ignored in this case).
    ///
    /// This method must only be called when the interface is online
    /// (Specifically, either attaching, attached, or isolated). If the
    /// interface is in any other state, the channel will be closed with
    /// `ZX_ERR_BAD_STATE`.
    ///
    /// `duration` specifies a minimum time the interface should be made
    /// joinable, relative to the time the call is received. It may be rounded
    /// up to the nearest second.
    ///
    /// `port` specifies the local port that TCP or UDP commissioning traffic
    /// will be directed to.
    pub fn r#make_joinable(
        &self,
        mut duration: i64,
        mut port: u16,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        LegacyJoiningProxyInterface::r#make_joinable(self, duration, port)
    }
}

impl LegacyJoiningProxyInterface for LegacyJoiningProxy {
    type MakeJoinableResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#make_joinable(&self, mut duration: i64, mut port: u16) -> Self::MakeJoinableResponseFut {
        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,
                0x1739a6ae36d5c5aa,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<LegacyJoiningMakeJoinableRequest, ()>(
            (duration, port),
            0x1739a6ae36d5c5aa,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for LegacyJoiningRequestStream {
    type Protocol = LegacyJoiningMarker;
    type ControlHandle = LegacyJoiningControlHandle;

    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 {
        LegacyJoiningControlHandle { 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 LegacyJoiningRequestStream {
    type Item = Result<LegacyJoiningRequest, 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 LegacyJoiningRequestStream 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 {
                    0x1739a6ae36d5c5aa => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            LegacyJoiningMakeJoinableRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<LegacyJoiningMakeJoinableRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            LegacyJoiningControlHandle { inner: this.inner.clone() };
                        Ok(LegacyJoiningRequest::MakeJoinable {
                            duration: req.duration,
                            port: req.port,

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

/// Protocol for supporting non-standard in-band commissioning protocols.
/// Only one instance of this protocol may be valid at a time: after the
/// first request all subsequent requests for this protocol will fail until
/// the first instance is closed.
#[derive(Debug)]
pub enum LegacyJoiningRequest {
    /// Makes the interface joinable for Thread devices that need to use a
    /// non-standard in-band commissioning protocol. It is not used for
    /// standard Thread commissioning.
    ///
    /// When this call returns, the interface has been made joinable if
    /// requested.
    ///
    /// Subsequent calls to this method will override previous calls.
    /// To force the interface to no longer be joinable immediately, call
    /// this method with a duration of zero seconds and a port of zero (port
    /// is ignored in this case).
    ///
    /// This method must only be called when the interface is online
    /// (Specifically, either attaching, attached, or isolated). If the
    /// interface is in any other state, the channel will be closed with
    /// `ZX_ERR_BAD_STATE`.
    ///
    /// `duration` specifies a minimum time the interface should be made
    /// joinable, relative to the time the call is received. It may be rounded
    /// up to the nearest second.
    ///
    /// `port` specifies the local port that TCP or UDP commissioning traffic
    /// will be directed to.
    MakeJoinable { duration: i64, port: u16, responder: LegacyJoiningMakeJoinableResponder },
}

impl LegacyJoiningRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_make_joinable(self) -> Option<(i64, u16, LegacyJoiningMakeJoinableResponder)> {
        if let LegacyJoiningRequest::MakeJoinable { duration, port, responder } = self {
            Some((duration, port, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for LegacyJoiningConnectorMarker {
    type Proxy = LegacyJoiningConnectorProxy;
    type RequestStream = LegacyJoiningConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = LegacyJoiningConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.lowpan.experimental.LegacyJoiningConnector";
}
impl fidl::endpoints::DiscoverableProtocolMarker for LegacyJoiningConnectorMarker {}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for LegacyJoiningConnectorSynchronousProxy {
    type Proxy = LegacyJoiningConnectorProxy;
    type Protocol = LegacyJoiningConnectorMarker;

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

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

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

    /// Connects to the [`LegacyJoining`] 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<LegacyJoiningMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<LegacyJoiningConnectorConnectRequest>(
            (name, server_end),
            0x3c8dfeb943bb8d06,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for LegacyJoiningConnectorProxy {
    type Protocol = LegacyJoiningConnectorMarker;

    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 LegacyJoiningConnectorProxy {
    /// Create a new Proxy for fuchsia.lowpan.experimental/LegacyJoiningConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <LegacyJoiningConnectorMarker 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) -> LegacyJoiningConnectorEventStream {
        LegacyJoiningConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connects to the [`LegacyJoining`] 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<LegacyJoiningMarker>,
    ) -> Result<(), fidl::Error> {
        LegacyJoiningConnectorProxyInterface::r#connect(self, name, server_end)
    }
}

impl LegacyJoiningConnectorProxyInterface for LegacyJoiningConnectorProxy {
    fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<LegacyJoiningMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<LegacyJoiningConnectorConnectRequest>(
            (name, server_end),
            0x3c8dfeb943bb8d06,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for LegacyJoiningConnectorRequestStream {
    type Protocol = LegacyJoiningConnectorMarker;
    type ControlHandle = LegacyJoiningConnectorControlHandle;

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

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

/// Protocol for connecting to [`LegacyJoining`] on a LoWPAN
/// interface.
#[derive(Debug)]
pub enum LegacyJoiningConnectorRequest {
    /// Connects to the [`LegacyJoining`] 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<LegacyJoiningMarker>,
        control_handle: LegacyJoiningConnectorControlHandle,
    },
}

impl LegacyJoiningConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(
        String,
        fidl::endpoints::ServerEnd<LegacyJoiningMarker>,
        LegacyJoiningConnectorControlHandle,
    )> {
        if let LegacyJoiningConnectorRequest::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 {
            LegacyJoiningConnectorRequest::Connect { .. } => "connect",
        }
    }
}

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

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

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

impl fidl::endpoints::ProtocolMarker for ProvisioningMonitorMarker {
    type Proxy = ProvisioningMonitorProxy;
    type RequestStream = ProvisioningMonitorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ProvisioningMonitorSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) ProvisioningMonitor";
}
pub type ProvisioningMonitorWatchProgressResult = Result<ProvisioningProgress, ProvisionError>;

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ProvisioningMonitorSynchronousProxy {
    type Proxy = ProvisioningMonitorProxy;
    type Protocol = ProvisioningMonitorMarker;

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

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

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

    /// Call this method to receive an update on the provisioning progress.
    ///
    /// When first called, this method will return immediately with the
    /// current status. On subsequent calls, it will block until the status
    /// changes.
    ///
    /// If provisioning error is encountered, it is returned as a
    /// [`ProvisionError`]. See the documentation for [`ProvisionError`]
    /// details on error handling.
    ///
    /// Once the method has either returned an identity or indicated a
    /// [`ProvisionError`], the ProvisioningMonitor will close with `ZX_OK`.
    pub fn r#watch_progress(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProvisioningMonitorWatchProgressResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                ProvisioningMonitorWatchProgressResponse,
                ProvisionError,
            >>(
                (),
                0xc35336fc43ac0c,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.progress))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ProvisioningMonitorProxy {
    type Protocol = ProvisioningMonitorMarker;

    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 ProvisioningMonitorProxy {
    /// Create a new Proxy for fuchsia.lowpan.experimental/ProvisioningMonitor.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <ProvisioningMonitorMarker 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) -> ProvisioningMonitorEventStream {
        ProvisioningMonitorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Call this method to receive an update on the provisioning progress.
    ///
    /// When first called, this method will return immediately with the
    /// current status. On subsequent calls, it will block until the status
    /// changes.
    ///
    /// If provisioning error is encountered, it is returned as a
    /// [`ProvisionError`]. See the documentation for [`ProvisionError`]
    /// details on error handling.
    ///
    /// Once the method has either returned an identity or indicated a
    /// [`ProvisionError`], the ProvisioningMonitor will close with `ZX_OK`.
    pub fn r#watch_progress(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ProvisioningMonitorWatchProgressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProvisioningMonitorProxyInterface::r#watch_progress(self)
    }
}

impl ProvisioningMonitorProxyInterface for ProvisioningMonitorProxy {
    type WatchProgressResponseFut = fidl::client::QueryResponseFut<
        ProvisioningMonitorWatchProgressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#watch_progress(&self) -> Self::WatchProgressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProvisioningMonitorWatchProgressResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    ProvisioningMonitorWatchProgressResponse,
                    ProvisionError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xc35336fc43ac0c,
            >(_buf?)?;
            Ok(_response.map(|x| x.progress))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            ProvisioningMonitorWatchProgressResult,
        >(
            (),
            0xc35336fc43ac0c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ProvisioningMonitorRequestStream {
    type Protocol = ProvisioningMonitorMarker;
    type ControlHandle = ProvisioningMonitorControlHandle;

    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 {
        ProvisioningMonitorControlHandle { 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 ProvisioningMonitorRequestStream {
    type Item = Result<ProvisioningMonitorRequest, 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 ProvisioningMonitorRequestStream 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 {
                0xc35336fc43ac0c => {
                    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 = ProvisioningMonitorControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ProvisioningMonitorRequest::WatchProgress {
                        responder: ProvisioningMonitorWatchProgressResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <ProvisioningMonitorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Reports the progress of a provisioning operation like Join or Form.
///
/// If there was a problem with the arguments passed to the originating
/// function (Join/Form) then the channel will be closed with `ZX_ERR_INVALID_ARGS`.
#[derive(Debug)]
pub enum ProvisioningMonitorRequest {
    /// Call this method to receive an update on the provisioning progress.
    ///
    /// When first called, this method will return immediately with the
    /// current status. On subsequent calls, it will block until the status
    /// changes.
    ///
    /// If provisioning error is encountered, it is returned as a
    /// [`ProvisionError`]. See the documentation for [`ProvisionError`]
    /// details on error handling.
    ///
    /// Once the method has either returned an identity or indicated a
    /// [`ProvisionError`], the ProvisioningMonitor will close with `ZX_OK`.
    WatchProgress { responder: ProvisioningMonitorWatchProgressResponder },
}

impl ProvisioningMonitorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_watch_progress(self) -> Option<(ProvisioningMonitorWatchProgressResponder)> {
        if let ProvisioningMonitorRequest::WatchProgress { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<&ProvisioningProgress, ProvisionError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ProvisioningMonitorWatchProgressResponse,
            ProvisionError,
        >>(
            result.map(|progress| (progress,)),
            self.tx_id,
            0xc35336fc43ac0c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for TelemetryProviderMarker {
    type Proxy = TelemetryProviderProxy;
    type RequestStream = TelemetryProviderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = TelemetryProviderSynchronousProxy;

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for TelemetryProviderSynchronousProxy {
    type Proxy = TelemetryProviderProxy;
    type Protocol = TelemetryProviderMarker;

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

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

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

    /// Returns a snapshot the telemetry information table.
    pub fn r#get_telemetry(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Telemetry, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, TelemetryProviderGetTelemetryResponse>(
                (),
                0xc34f2fff7dacc41,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.telemetry)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for TelemetryProviderProxy {
    type Protocol = TelemetryProviderMarker;

    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 TelemetryProviderProxy {
    /// Create a new Proxy for fuchsia.lowpan.experimental/TelemetryProvider.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <TelemetryProviderMarker 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) -> TelemetryProviderEventStream {
        TelemetryProviderEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns a snapshot the telemetry information table.
    pub fn r#get_telemetry(
        &self,
    ) -> fidl::client::QueryResponseFut<Telemetry, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        TelemetryProviderProxyInterface::r#get_telemetry(self)
    }
}

impl TelemetryProviderProxyInterface for TelemetryProviderProxy {
    type GetTelemetryResponseFut =
        fidl::client::QueryResponseFut<Telemetry, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_telemetry(&self) -> Self::GetTelemetryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Telemetry, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                TelemetryProviderGetTelemetryResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xc34f2fff7dacc41,
            >(_buf?)?;
            Ok(_response.telemetry)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Telemetry>(
            (),
            0xc34f2fff7dacc41,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for TelemetryProviderRequestStream {
    type Protocol = TelemetryProviderMarker;
    type ControlHandle = TelemetryProviderControlHandle;

    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 {
        TelemetryProviderControlHandle { 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 TelemetryProviderRequestStream {
    type Item = Result<TelemetryProviderRequest, 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 TelemetryProviderRequestStream 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 {
                    0xc34f2fff7dacc41 => {
                        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 =
                            TelemetryProviderControlHandle { inner: this.inner.clone() };
                        Ok(TelemetryProviderRequest::GetTelemetry {
                            responder: TelemetryProviderGetTelemetryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <TelemetryProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Provides telemetry data for an individual interface to the LoWPAN service.
#[derive(Debug)]
pub enum TelemetryProviderRequest {
    /// Returns a snapshot the telemetry information table.
    GetTelemetry { responder: TelemetryProviderGetTelemetryResponder },
}

impl TelemetryProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_telemetry(self) -> Option<(TelemetryProviderGetTelemetryResponder)> {
        if let TelemetryProviderRequest::GetTelemetry { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

    fn send_raw(&self, mut telemetry: &Telemetry) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<TelemetryProviderGetTelemetryResponse>(
            (telemetry,),
            self.tx_id,
            0xc34f2fff7dacc41,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for TelemetryProviderConnectorMarker {
    type Proxy = TelemetryProviderConnectorProxy;
    type RequestStream = TelemetryProviderConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = TelemetryProviderConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.lowpan.experimental.TelemetryProviderConnector";
}
impl fidl::endpoints::DiscoverableProtocolMarker for TelemetryProviderConnectorMarker {}

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for TelemetryProviderConnectorSynchronousProxy {
    type Proxy = TelemetryProviderConnectorProxy;
    type Protocol = TelemetryProviderConnectorMarker;

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

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

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

    /// Connects to the [`TelemetryProvider`] 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<TelemetryProviderMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<TelemetryProviderConnectorConnectRequest>(
            (name, server_end),
            0x24a5bf1be73e2fad,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for TelemetryProviderConnectorProxy {
    type Protocol = TelemetryProviderConnectorMarker;

    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 TelemetryProviderConnectorProxy {
    /// Create a new Proxy for fuchsia.lowpan.experimental/TelemetryProviderConnector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <TelemetryProviderConnectorMarker 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) -> TelemetryProviderConnectorEventStream {
        TelemetryProviderConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Connects to the [`TelemetryProvider`] 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<TelemetryProviderMarker>,
    ) -> Result<(), fidl::Error> {
        TelemetryProviderConnectorProxyInterface::r#connect(self, name, server_end)
    }
}

impl TelemetryProviderConnectorProxyInterface for TelemetryProviderConnectorProxy {
    fn r#connect(
        &self,
        mut name: &str,
        mut server_end: fidl::endpoints::ServerEnd<TelemetryProviderMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<TelemetryProviderConnectorConnectRequest>(
            (name, server_end),
            0x24a5bf1be73e2fad,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for TelemetryProviderConnectorRequestStream {
    type Protocol = TelemetryProviderConnectorMarker;
    type ControlHandle = TelemetryProviderConnectorControlHandle;

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

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

/// Protocol for connecting to [`TelemetryProvider`] on a LoWPAN interface.
#[derive(Debug)]
pub enum TelemetryProviderConnectorRequest {
    /// Connects to the [`TelemetryProvider`] 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<TelemetryProviderMarker>,
        control_handle: TelemetryProviderConnectorControlHandle,
    },
}

impl TelemetryProviderConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(
        String,
        fidl::endpoints::ServerEnd<TelemetryProviderMarker>,
        TelemetryProviderConnectorControlHandle,
    )> {
        if let TelemetryProviderConnectorRequest::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 {
            TelemetryProviderConnectorRequest::Connect { .. } => "connect",
        }
    }
}

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

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

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for DeviceConnectorConnectRequest {
        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 DeviceConnectorConnectRequest {
        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<
            DeviceConnectorConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DeviceConnectorConnectRequest
    {
        #[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::<DeviceConnectorConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceConnectorConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceMarker>> 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<DeviceMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DeviceConnectorConnectRequest,
            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::<DeviceConnectorConnectRequest>(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 DeviceConnectorConnectRequest
    {
        #[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<DeviceMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            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<DeviceMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.server_end,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DeviceExtraConnectorConnectRequest {
        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 DeviceExtraConnectorConnectRequest {
        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<
            DeviceExtraConnectorConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DeviceExtraConnectorConnectRequest
    {
        #[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::<DeviceExtraConnectorConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceExtraConnectorConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceExtraMarker>> 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<DeviceExtraMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DeviceExtraConnectorConnectRequest,
            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::<DeviceExtraConnectorConnectRequest>(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 DeviceExtraConnectorConnectRequest
    {
        #[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<DeviceExtraMarker>>,
                    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<DeviceExtraMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.server_end,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            DeviceExtraFormNetworkRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DeviceExtraFormNetworkRequest
    {
        #[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::<DeviceExtraFormNetworkRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceExtraFormNetworkRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_lowpan_device::ProvisioningParams as fidl::encoding::ValueTypeMarker>::borrow(&self.params),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.progress),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl_fuchsia_lowpan_device::ProvisioningParams,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DeviceExtraFormNetworkRequest,
            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::<DeviceExtraFormNetworkRequest>(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(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DeviceExtraFormNetworkRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                params: fidl::new_empty!(
                    fidl_fuchsia_lowpan_device::ProvisioningParams,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                progress: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>>,
                    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(32) };
            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 + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl_fuchsia_lowpan_device::ProvisioningParams,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.params,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.progress,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DeviceExtraJoinNetworkRequest {
        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 DeviceExtraJoinNetworkRequest {
        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<
            DeviceExtraJoinNetworkRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DeviceExtraJoinNetworkRequest
    {
        #[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::<DeviceExtraJoinNetworkRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceExtraJoinNetworkRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <JoinParams as fidl::encoding::ValueTypeMarker>::borrow(&self.params),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.progress),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<JoinParams, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DeviceExtraJoinNetworkRequest,
            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::<DeviceExtraJoinNetworkRequest>(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 DeviceExtraJoinNetworkRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                params: fidl::new_empty!(JoinParams, fidl::encoding::DefaultFuchsiaResourceDialect),
                progress: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>>,
                    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!(
                JoinParams,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.params,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProvisioningMonitorMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.progress,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DeviceExtraStartNetworkScanRequest {
        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 DeviceExtraStartNetworkScanRequest {
        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<
            DeviceExtraStartNetworkScanRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DeviceExtraStartNetworkScanRequest
    {
        #[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::<DeviceExtraStartNetworkScanRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceExtraStartNetworkScanRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <NetworkScanParameters as fidl::encoding::ValueTypeMarker>::borrow(&self.params),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BeaconInfoStreamMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.stream),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                NetworkScanParameters,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BeaconInfoStreamMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DeviceExtraStartNetworkScanRequest,
            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::<DeviceExtraStartNetworkScanRequest>(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 DeviceExtraStartNetworkScanRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                params: fidl::new_empty!(
                    NetworkScanParameters,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                stream: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BeaconInfoStreamMarker>>,
                    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!(
                NetworkScanParameters,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.params,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<BeaconInfoStreamMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.stream,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DeviceRouteConnectorConnectRequest {
        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 DeviceRouteConnectorConnectRequest {
        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<
            DeviceRouteConnectorConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DeviceRouteConnectorConnectRequest
    {
        #[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::<DeviceRouteConnectorConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceRouteConnectorConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceRouteMarker>> 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<DeviceRouteMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DeviceRouteConnectorConnectRequest,
            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::<DeviceRouteConnectorConnectRequest>(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 DeviceRouteConnectorConnectRequest
    {
        #[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<DeviceRouteMarker>>,
                    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<DeviceRouteMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.server_end,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DeviceRouteExtraConnectorConnectRequest {
        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 DeviceRouteExtraConnectorConnectRequest {
        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<
            DeviceRouteExtraConnectorConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DeviceRouteExtraConnectorConnectRequest
    {
        #[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::<DeviceRouteExtraConnectorConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DeviceRouteExtraConnectorConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceRouteExtraMarker>> 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<DeviceRouteExtraMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DeviceRouteExtraConnectorConnectRequest,
            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::<DeviceRouteExtraConnectorConnectRequest>(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 DeviceRouteExtraConnectorConnectRequest
    {
        #[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<DeviceRouteExtraMarker>>,
                    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<DeviceRouteExtraMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.server_end,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for LegacyJoiningConnectorConnectRequest {
        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 LegacyJoiningConnectorConnectRequest {
        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<
            LegacyJoiningConnectorConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut LegacyJoiningConnectorConnectRequest
    {
        #[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::<LegacyJoiningConnectorConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<LegacyJoiningConnectorConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<LegacyJoiningMarker>> 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<LegacyJoiningMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            LegacyJoiningConnectorConnectRequest,
            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::<LegacyJoiningConnectorConnectRequest>(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 LegacyJoiningConnectorConnectRequest
    {
        #[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<LegacyJoiningMarker>>,
                    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<LegacyJoiningMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.server_end,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TelemetryProviderConnectorConnectRequest {
        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 TelemetryProviderConnectorConnectRequest {
        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<
            TelemetryProviderConnectorConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TelemetryProviderConnectorConnectRequest
    {
        #[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::<TelemetryProviderConnectorConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TelemetryProviderConnectorConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<TelemetryProviderMarker>> 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<TelemetryProviderMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            TelemetryProviderConnectorConnectRequest,
            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::<TelemetryProviderConnectorConnectRequest>(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 TelemetryProviderConnectorConnectRequest
    {
        #[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<TelemetryProviderMarker>>,
                    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<TelemetryProviderMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.server_end,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }
}