fidl_fuchsia_net_settings/

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

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

impl fidl::endpoints::ProtocolMarker for ControlMarker {
    type Proxy = ControlProxy;
    type RequestStream = ControlRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ControlSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.net.settings.Control";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ControlMarker {}
pub type ControlUpdateInterfaceDefaultsResult =
    Result<fidl_fuchsia_net_interfaces_admin::Configuration, UpdateError>;
pub type ControlUpdateTcpResult = Result<Tcp, UpdateError>;
pub type ControlUpdateUdpResult = Result<Udp, UpdateError>;
pub type ControlUpdateIcmpResult = Result<Icmp, UpdateError>;
pub type ControlUpdateIpResult = Result<Ip, UpdateError>;
pub type ControlUpdateDeviceResult = Result<Device, UpdateError>;

pub trait ControlProxyInterface: Send + Sync {
    type UpdateInterfaceDefaultsResponseFut: std::future::Future<Output = Result<ControlUpdateInterfaceDefaultsResult, fidl::Error>>
        + Send;
    fn r#update_interface_defaults(
        &self,
        payload: &fidl_fuchsia_net_interfaces_admin::Configuration,
    ) -> Self::UpdateInterfaceDefaultsResponseFut;
    type UpdateTcpResponseFut: std::future::Future<Output = Result<ControlUpdateTcpResult, fidl::Error>>
        + Send;
    fn r#update_tcp(&self, payload: &Tcp) -> Self::UpdateTcpResponseFut;
    type UpdateUdpResponseFut: std::future::Future<Output = Result<ControlUpdateUdpResult, fidl::Error>>
        + Send;
    fn r#update_udp(&self, payload: &Udp) -> Self::UpdateUdpResponseFut;
    type UpdateIcmpResponseFut: std::future::Future<Output = Result<ControlUpdateIcmpResult, fidl::Error>>
        + Send;
    fn r#update_icmp(&self, payload: &Icmp) -> Self::UpdateIcmpResponseFut;
    type UpdateIpResponseFut: std::future::Future<Output = Result<ControlUpdateIpResult, fidl::Error>>
        + Send;
    fn r#update_ip(&self, payload: &Ip) -> Self::UpdateIpResponseFut;
    type UpdateDeviceResponseFut: std::future::Future<Output = Result<ControlUpdateDeviceResult, fidl::Error>>
        + Send;
    fn r#update_device(&self, payload: &Device) -> Self::UpdateDeviceResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ControlSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ControlSynchronousProxy {
    type Proxy = ControlProxy;
    type Protocol = ControlMarker;

    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 ControlSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Updates the default configurations for interfaces.
    ///
    /// New interfaces created take default values from this configuration.
    ///
    /// Note that some interface types may not support specific configurations,
    /// in which case the value is either ignored or the network stack assigns a
    /// server-assigned value.
    ///
    /// Only fields present in the provided [`Interface`] are set; unset fields
    /// are left unmodified. The server returns a `Interface` which holds the
    /// previous configuration for fields that were set in the request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request configuration fields to update on the interface defaults.
    /// - response a partial snapshot of the previous default configuration.
    pub fn r#update_interface_defaults(
        &self,
        mut payload: &fidl_fuchsia_net_interfaces_admin::Configuration,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControlUpdateInterfaceDefaultsResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl_fuchsia_net_interfaces_admin::Configuration,
            fidl::encoding::ResultType<fidl_fuchsia_net_interfaces_admin::Configuration, UpdateError>,
            ControlMarker,
        >(
            payload,
            0x46ea2036390abecc,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Updates TCP settings.
    ///
    /// Only fields present in the provided [`Tcp`] are set; unset fields are
    /// left unmodified. The server returns a `Tcp` which holds the previous
    /// settings for fields that were set in the request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request TCP settings fields to update.
    /// - response a partial snapshot of the previous TCP settings.
    pub fn r#update_tcp(
        &self,
        mut payload: &Tcp,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControlUpdateTcpResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<Tcp, fidl::encoding::ResultType<Tcp, UpdateError>, ControlMarker>(
                payload,
                0x4e768d74ec55450f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Updates UDP settings.
    ///
    /// Only fields present in the provided [`Udp`] are set; unset fields are
    /// left unmodified. The server returns a `Udp` which holds the previous
    /// settings for fields that were set in the request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request UDP settings fields to update.
    /// - response a partial snapshot of the previous UDP settings.
    pub fn r#update_udp(
        &self,
        mut payload: &Udp,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControlUpdateUdpResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<Udp, fidl::encoding::ResultType<Udp, UpdateError>, ControlMarker>(
                payload,
                0x6fb82be32e7338b4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Updates ICMP settings.
    ///
    /// Only fields present in the provided [`Icmp`] are set; unset fields are
    /// left unmodified. The server returns a `Icmp` which holds the previous
    /// settings for fields that were set in the request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request ICMP settings fields to update.
    /// - response a partial snapshot of the previous ICMP settings.
    pub fn r#update_icmp(
        &self,
        mut payload: &Icmp,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControlUpdateIcmpResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<Icmp, fidl::encoding::ResultType<Icmp, UpdateError>, ControlMarker>(
                payload,
                0x42f130ff9cc3a8d5,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Updates IP settings.
    ///
    /// Only fields present in the provided [`Ip`] are set; unset fields are
    /// left unmodified. The server returns a `Ip` which holds the previous
    /// settings for fields that were set in the request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request IP settings fields to update.
    /// - response a partial snapshot of the previous IP settings.
    pub fn r#update_ip(
        &self,
        mut payload: &Ip,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControlUpdateIpResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<Ip, fidl::encoding::ResultType<Ip, UpdateError>, ControlMarker>(
                payload,
                0x75d1074407e4d1c4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Updates device layer settings.
    ///
    /// Only fields present in the provided [`Device`] are set; unset
    /// fields are left unmodified. The server returns a `Device` which
    /// holds the previous settings for fields that were set in the
    /// request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request device layer settings fields to update.
    /// - response a partial snapshot of the previous device layer.
    pub fn r#update_device(
        &self,
        mut payload: &Device,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ControlUpdateDeviceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<Device, fidl::encoding::ResultType<Device, UpdateError>, ControlMarker>(
                payload,
                0x6080a91e617e9430,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ControlProxy {
    type Protocol = ControlMarker;

    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 ControlProxy {
    /// Create a new Proxy for fuchsia.net.settings/Control.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ControlMarker 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) -> ControlEventStream {
        ControlEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Updates the default configurations for interfaces.
    ///
    /// New interfaces created take default values from this configuration.
    ///
    /// Note that some interface types may not support specific configurations,
    /// in which case the value is either ignored or the network stack assigns a
    /// server-assigned value.
    ///
    /// Only fields present in the provided [`Interface`] are set; unset fields
    /// are left unmodified. The server returns a `Interface` which holds the
    /// previous configuration for fields that were set in the request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request configuration fields to update on the interface defaults.
    /// - response a partial snapshot of the previous default configuration.
    pub fn r#update_interface_defaults(
        &self,
        mut payload: &fidl_fuchsia_net_interfaces_admin::Configuration,
    ) -> fidl::client::QueryResponseFut<
        ControlUpdateInterfaceDefaultsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControlProxyInterface::r#update_interface_defaults(self, payload)
    }

    /// Updates TCP settings.
    ///
    /// Only fields present in the provided [`Tcp`] are set; unset fields are
    /// left unmodified. The server returns a `Tcp` which holds the previous
    /// settings for fields that were set in the request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request TCP settings fields to update.
    /// - response a partial snapshot of the previous TCP settings.
    pub fn r#update_tcp(
        &self,
        mut payload: &Tcp,
    ) -> fidl::client::QueryResponseFut<
        ControlUpdateTcpResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControlProxyInterface::r#update_tcp(self, payload)
    }

    /// Updates UDP settings.
    ///
    /// Only fields present in the provided [`Udp`] are set; unset fields are
    /// left unmodified. The server returns a `Udp` which holds the previous
    /// settings for fields that were set in the request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request UDP settings fields to update.
    /// - response a partial snapshot of the previous UDP settings.
    pub fn r#update_udp(
        &self,
        mut payload: &Udp,
    ) -> fidl::client::QueryResponseFut<
        ControlUpdateUdpResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControlProxyInterface::r#update_udp(self, payload)
    }

    /// Updates ICMP settings.
    ///
    /// Only fields present in the provided [`Icmp`] are set; unset fields are
    /// left unmodified. The server returns a `Icmp` which holds the previous
    /// settings for fields that were set in the request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request ICMP settings fields to update.
    /// - response a partial snapshot of the previous ICMP settings.
    pub fn r#update_icmp(
        &self,
        mut payload: &Icmp,
    ) -> fidl::client::QueryResponseFut<
        ControlUpdateIcmpResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControlProxyInterface::r#update_icmp(self, payload)
    }

    /// Updates IP settings.
    ///
    /// Only fields present in the provided [`Ip`] are set; unset fields are
    /// left unmodified. The server returns a `Ip` which holds the previous
    /// settings for fields that were set in the request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request IP settings fields to update.
    /// - response a partial snapshot of the previous IP settings.
    pub fn r#update_ip(
        &self,
        mut payload: &Ip,
    ) -> fidl::client::QueryResponseFut<
        ControlUpdateIpResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControlProxyInterface::r#update_ip(self, payload)
    }

    /// Updates device layer settings.
    ///
    /// Only fields present in the provided [`Device`] are set; unset
    /// fields are left unmodified. The server returns a `Device` which
    /// holds the previous settings for fields that were set in the
    /// request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request device layer settings fields to update.
    /// - response a partial snapshot of the previous device layer.
    pub fn r#update_device(
        &self,
        mut payload: &Device,
    ) -> fidl::client::QueryResponseFut<
        ControlUpdateDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ControlProxyInterface::r#update_device(self, payload)
    }
}

impl ControlProxyInterface for ControlProxy {
    type UpdateInterfaceDefaultsResponseFut = fidl::client::QueryResponseFut<
        ControlUpdateInterfaceDefaultsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#update_interface_defaults(
        &self,
        mut payload: &fidl_fuchsia_net_interfaces_admin::Configuration,
    ) -> Self::UpdateInterfaceDefaultsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControlUpdateInterfaceDefaultsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    fidl_fuchsia_net_interfaces_admin::Configuration,
                    UpdateError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x46ea2036390abecc,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl_fuchsia_net_interfaces_admin::Configuration,
            ControlUpdateInterfaceDefaultsResult,
        >(
            payload,
            0x46ea2036390abecc,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UpdateTcpResponseFut = fidl::client::QueryResponseFut<
        ControlUpdateTcpResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#update_tcp(&self, mut payload: &Tcp) -> Self::UpdateTcpResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControlUpdateTcpResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<Tcp, UpdateError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4e768d74ec55450f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<Tcp, ControlUpdateTcpResult>(
            payload,
            0x4e768d74ec55450f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UpdateUdpResponseFut = fidl::client::QueryResponseFut<
        ControlUpdateUdpResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#update_udp(&self, mut payload: &Udp) -> Self::UpdateUdpResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControlUpdateUdpResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<Udp, UpdateError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6fb82be32e7338b4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<Udp, ControlUpdateUdpResult>(
            payload,
            0x6fb82be32e7338b4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UpdateIcmpResponseFut = fidl::client::QueryResponseFut<
        ControlUpdateIcmpResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#update_icmp(&self, mut payload: &Icmp) -> Self::UpdateIcmpResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControlUpdateIcmpResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<Icmp, UpdateError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x42f130ff9cc3a8d5,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<Icmp, ControlUpdateIcmpResult>(
            payload,
            0x42f130ff9cc3a8d5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UpdateIpResponseFut = fidl::client::QueryResponseFut<
        ControlUpdateIpResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#update_ip(&self, mut payload: &Ip) -> Self::UpdateIpResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControlUpdateIpResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<Ip, UpdateError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x75d1074407e4d1c4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<Ip, ControlUpdateIpResult>(
            payload,
            0x75d1074407e4d1c4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type UpdateDeviceResponseFut = fidl::client::QueryResponseFut<
        ControlUpdateDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#update_device(&self, mut payload: &Device) -> Self::UpdateDeviceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ControlUpdateDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<Device, UpdateError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6080a91e617e9430,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<Device, ControlUpdateDeviceResult>(
            payload,
            0x6080a91e617e9430,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.settings/Control.
pub struct ControlRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ControlRequestStream {
    type Protocol = ControlMarker;
    type ControlHandle = ControlControlHandle;

    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 {
        ControlControlHandle { 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 ControlRequestStream {
    type Item = Result<ControlRequest, 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 ControlRequestStream 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 {
                    0x46ea2036390abecc => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl_fuchsia_net_interfaces_admin::Configuration,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_net_interfaces_admin::Configuration>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControlControlHandle { inner: this.inner.clone() };
                        Ok(ControlRequest::UpdateInterfaceDefaults {
                            payload: req,
                            responder: ControlUpdateInterfaceDefaultsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4e768d74ec55450f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req =
                            fidl::new_empty!(Tcp, fidl::encoding::DefaultFuchsiaResourceDialect);
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<Tcp>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControlControlHandle { inner: this.inner.clone() };
                        Ok(ControlRequest::UpdateTcp {
                            payload: req,
                            responder: ControlUpdateTcpResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6fb82be32e7338b4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req =
                            fidl::new_empty!(Udp, fidl::encoding::DefaultFuchsiaResourceDialect);
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<Udp>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControlControlHandle { inner: this.inner.clone() };
                        Ok(ControlRequest::UpdateUdp {
                            payload: req,
                            responder: ControlUpdateUdpResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x42f130ff9cc3a8d5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req =
                            fidl::new_empty!(Icmp, fidl::encoding::DefaultFuchsiaResourceDialect);
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<Icmp>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControlControlHandle { inner: this.inner.clone() };
                        Ok(ControlRequest::UpdateIcmp {
                            payload: req,
                            responder: ControlUpdateIcmpResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x75d1074407e4d1c4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req =
                            fidl::new_empty!(Ip, fidl::encoding::DefaultFuchsiaResourceDialect);
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<Ip>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControlControlHandle { inner: this.inner.clone() };
                        Ok(ControlRequest::UpdateIp {
                            payload: req,
                            responder: ControlUpdateIpResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6080a91e617e9430 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req =
                            fidl::new_empty!(Device, fidl::encoding::DefaultFuchsiaResourceDialect);
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<Device>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ControlControlHandle { inner: this.inner.clone() };
                        Ok(ControlRequest::UpdateDevice {
                            payload: req,
                            responder: ControlUpdateDeviceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ControlMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Provides control over the network stack namespace-wide configuration.
#[derive(Debug)]
pub enum ControlRequest {
    /// Updates the default configurations for interfaces.
    ///
    /// New interfaces created take default values from this configuration.
    ///
    /// Note that some interface types may not support specific configurations,
    /// in which case the value is either ignored or the network stack assigns a
    /// server-assigned value.
    ///
    /// Only fields present in the provided [`Interface`] are set; unset fields
    /// are left unmodified. The server returns a `Interface` which holds the
    /// previous configuration for fields that were set in the request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request configuration fields to update on the interface defaults.
    /// - response a partial snapshot of the previous default configuration.
    UpdateInterfaceDefaults {
        payload: fidl_fuchsia_net_interfaces_admin::Configuration,
        responder: ControlUpdateInterfaceDefaultsResponder,
    },
    /// Updates TCP settings.
    ///
    /// Only fields present in the provided [`Tcp`] are set; unset fields are
    /// left unmodified. The server returns a `Tcp` which holds the previous
    /// settings for fields that were set in the request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request TCP settings fields to update.
    /// - response a partial snapshot of the previous TCP settings.
    UpdateTcp { payload: Tcp, responder: ControlUpdateTcpResponder },
    /// Updates UDP settings.
    ///
    /// Only fields present in the provided [`Udp`] are set; unset fields are
    /// left unmodified. The server returns a `Udp` which holds the previous
    /// settings for fields that were set in the request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request UDP settings fields to update.
    /// - response a partial snapshot of the previous UDP settings.
    UpdateUdp { payload: Udp, responder: ControlUpdateUdpResponder },
    /// Updates ICMP settings.
    ///
    /// Only fields present in the provided [`Icmp`] are set; unset fields are
    /// left unmodified. The server returns a `Icmp` which holds the previous
    /// settings for fields that were set in the request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request ICMP settings fields to update.
    /// - response a partial snapshot of the previous ICMP settings.
    UpdateIcmp { payload: Icmp, responder: ControlUpdateIcmpResponder },
    /// Updates IP settings.
    ///
    /// Only fields present in the provided [`Ip`] are set; unset fields are
    /// left unmodified. The server returns a `Ip` which holds the previous
    /// settings for fields that were set in the request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request IP settings fields to update.
    /// - response a partial snapshot of the previous IP settings.
    UpdateIp { payload: Ip, responder: ControlUpdateIpResponder },
    /// Updates device layer settings.
    ///
    /// Only fields present in the provided [`Device`] are set; unset
    /// fields are left unmodified. The server returns a `Device` which
    /// holds the previous settings for fields that were set in the
    /// request.
    ///
    /// No values are changed if an error is returned.
    ///
    /// + request device layer settings fields to update.
    /// - response a partial snapshot of the previous device layer.
    UpdateDevice { payload: Device, responder: ControlUpdateDeviceResponder },
}

impl ControlRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_update_interface_defaults(
        self,
    ) -> Option<(
        fidl_fuchsia_net_interfaces_admin::Configuration,
        ControlUpdateInterfaceDefaultsResponder,
    )> {
        if let ControlRequest::UpdateInterfaceDefaults { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_update_tcp(self) -> Option<(Tcp, ControlUpdateTcpResponder)> {
        if let ControlRequest::UpdateTcp { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_update_udp(self) -> Option<(Udp, ControlUpdateUdpResponder)> {
        if let ControlRequest::UpdateUdp { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_update_icmp(self) -> Option<(Icmp, ControlUpdateIcmpResponder)> {
        if let ControlRequest::UpdateIcmp { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_update_ip(self) -> Option<(Ip, ControlUpdateIpResponder)> {
        if let ControlRequest::UpdateIp { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_update_device(self) -> Option<(Device, ControlUpdateDeviceResponder)> {
        if let ControlRequest::UpdateDevice { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ControlRequest::UpdateInterfaceDefaults { .. } => "update_interface_defaults",
            ControlRequest::UpdateTcp { .. } => "update_tcp",
            ControlRequest::UpdateUdp { .. } => "update_udp",
            ControlRequest::UpdateIcmp { .. } => "update_icmp",
            ControlRequest::UpdateIp { .. } => "update_ip",
            ControlRequest::UpdateDevice { .. } => "update_device",
        }
    }
}

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

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

impl fidl::endpoints::ControlHandle for ControlControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl ControlControlHandle {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for StateMarker {
    type Proxy = StateProxy;
    type RequestStream = StateRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = StateSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.net.settings.State";
}
impl fidl::endpoints::DiscoverableProtocolMarker for StateMarker {}

pub trait StateProxyInterface: Send + Sync {
    type GetInterfaceDefaultsResponseFut: std::future::Future<
            Output = Result<fidl_fuchsia_net_interfaces_admin::Configuration, fidl::Error>,
        > + Send;
    fn r#get_interface_defaults(&self) -> Self::GetInterfaceDefaultsResponseFut;
    type GetTcpResponseFut: std::future::Future<Output = Result<Tcp, fidl::Error>> + Send;
    fn r#get_tcp(&self) -> Self::GetTcpResponseFut;
    type GetUdpResponseFut: std::future::Future<Output = Result<Udp, fidl::Error>> + Send;
    fn r#get_udp(&self) -> Self::GetUdpResponseFut;
    type GetIcmpResponseFut: std::future::Future<Output = Result<Icmp, fidl::Error>> + Send;
    fn r#get_icmp(&self) -> Self::GetIcmpResponseFut;
    type GetIpResponseFut: std::future::Future<Output = Result<Ip, fidl::Error>> + Send;
    fn r#get_ip(&self) -> Self::GetIpResponseFut;
    type GetDeviceResponseFut: std::future::Future<Output = Result<Device, fidl::Error>> + Send;
    fn r#get_device(&self) -> Self::GetDeviceResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct StateSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for StateSynchronousProxy {
    type Proxy = StateProxy;
    type Protocol = StateMarker;

    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 StateSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Returns the current default settings for interfaces.
    pub fn r#get_interface_defaults(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_net_interfaces_admin::Configuration, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_net_interfaces_admin::Configuration,
            StateMarker,
        >(
            (),
            0x4c4824a322a705e3,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Returns the current TCP settings values.
    pub fn r#get_tcp(&self, ___deadline: zx::MonotonicInstant) -> Result<Tcp, fidl::Error> {
        let _response = self.client.send_query::<fidl::encoding::EmptyPayload, Tcp, StateMarker>(
            (),
            0x4e818d8a89985b70,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Returns the current UDP settings values.
    pub fn r#get_udp(&self, ___deadline: zx::MonotonicInstant) -> Result<Udp, fidl::Error> {
        let _response = self.client.send_query::<fidl::encoding::EmptyPayload, Udp, StateMarker>(
            (),
            0x1af3bc1507b7a196,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Returns the current ICMP settings values.
    pub fn r#get_icmp(&self, ___deadline: zx::MonotonicInstant) -> Result<Icmp, fidl::Error> {
        let _response = self.client.send_query::<fidl::encoding::EmptyPayload, Icmp, StateMarker>(
            (),
            0x4079fd71ca65e33f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Returns the current IP settings values.
    pub fn r#get_ip(&self, ___deadline: zx::MonotonicInstant) -> Result<Ip, fidl::Error> {
        let _response = self.client.send_query::<fidl::encoding::EmptyPayload, Ip, StateMarker>(
            (),
            0x2c1cc13f4874956,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Returns the current device layer settings values.
    pub fn r#get_device(&self, ___deadline: zx::MonotonicInstant) -> Result<Device, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, Device, StateMarker>(
                (),
                0x5713a85352e43887,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for StateProxy {
    type Protocol = StateMarker;

    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 StateProxy {
    /// Create a new Proxy for fuchsia.net.settings/State.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <StateMarker 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) -> StateEventStream {
        StateEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Returns the current default settings for interfaces.
    pub fn r#get_interface_defaults(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_net_interfaces_admin::Configuration,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StateProxyInterface::r#get_interface_defaults(self)
    }

    /// Returns the current TCP settings values.
    pub fn r#get_tcp(
        &self,
    ) -> fidl::client::QueryResponseFut<Tcp, fidl::encoding::DefaultFuchsiaResourceDialect> {
        StateProxyInterface::r#get_tcp(self)
    }

    /// Returns the current UDP settings values.
    pub fn r#get_udp(
        &self,
    ) -> fidl::client::QueryResponseFut<Udp, fidl::encoding::DefaultFuchsiaResourceDialect> {
        StateProxyInterface::r#get_udp(self)
    }

    /// Returns the current ICMP settings values.
    pub fn r#get_icmp(
        &self,
    ) -> fidl::client::QueryResponseFut<Icmp, fidl::encoding::DefaultFuchsiaResourceDialect> {
        StateProxyInterface::r#get_icmp(self)
    }

    /// Returns the current IP settings values.
    pub fn r#get_ip(
        &self,
    ) -> fidl::client::QueryResponseFut<Ip, fidl::encoding::DefaultFuchsiaResourceDialect> {
        StateProxyInterface::r#get_ip(self)
    }

    /// Returns the current device layer settings values.
    pub fn r#get_device(
        &self,
    ) -> fidl::client::QueryResponseFut<Device, fidl::encoding::DefaultFuchsiaResourceDialect> {
        StateProxyInterface::r#get_device(self)
    }
}

impl StateProxyInterface for StateProxy {
    type GetInterfaceDefaultsResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_net_interfaces_admin::Configuration,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_interface_defaults(&self) -> Self::GetInterfaceDefaultsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_net_interfaces_admin::Configuration, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl_fuchsia_net_interfaces_admin::Configuration,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4c4824a322a705e3,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_net_interfaces_admin::Configuration,
        >(
            (),
            0x4c4824a322a705e3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.net.settings/State.
pub struct StateRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for StateRequestStream {
    type Protocol = StateMarker;
    type ControlHandle = StateControlHandle;

    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 {
        StateControlHandle { 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 StateRequestStream {
    type Item = Result<StateRequest, 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 StateRequestStream 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 {
                    0x4c4824a322a705e3 => {
                        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 = StateControlHandle { inner: this.inner.clone() };
                        Ok(StateRequest::GetInterfaceDefaults {
                            responder: StateGetInterfaceDefaultsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4e818d8a89985b70 => {
                        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 = StateControlHandle { inner: this.inner.clone() };
                        Ok(StateRequest::GetTcp {
                            responder: StateGetTcpResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1af3bc1507b7a196 => {
                        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 = StateControlHandle { inner: this.inner.clone() };
                        Ok(StateRequest::GetUdp {
                            responder: StateGetUdpResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4079fd71ca65e33f => {
                        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 = StateControlHandle { inner: this.inner.clone() };
                        Ok(StateRequest::GetIcmp {
                            responder: StateGetIcmpResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c1cc13f4874956 => {
                        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 = StateControlHandle { inner: this.inner.clone() };
                        Ok(StateRequest::GetIp {
                            responder: StateGetIpResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5713a85352e43887 => {
                        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 = StateControlHandle { inner: this.inner.clone() };
                        Ok(StateRequest::GetDevice {
                            responder: StateGetDeviceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name: <StateMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Provides read access to the network stack namespace-wide settings.
#[derive(Debug)]
pub enum StateRequest {
    /// Returns the current default settings for interfaces.
    GetInterfaceDefaults { responder: StateGetInterfaceDefaultsResponder },
    /// Returns the current TCP settings values.
    GetTcp { responder: StateGetTcpResponder },
    /// Returns the current UDP settings values.
    GetUdp { responder: StateGetUdpResponder },
    /// Returns the current ICMP settings values.
    GetIcmp { responder: StateGetIcmpResponder },
    /// Returns the current IP settings values.
    GetIp { responder: StateGetIpResponder },
    /// Returns the current device layer settings values.
    GetDevice { responder: StateGetDeviceResponder },
}

impl StateRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_interface_defaults(self) -> Option<(StateGetInterfaceDefaultsResponder)> {
        if let StateRequest::GetInterfaceDefaults { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tcp(self) -> Option<(StateGetTcpResponder)> {
        if let StateRequest::GetTcp { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_udp(self) -> Option<(StateGetUdpResponder)> {
        if let StateRequest::GetUdp { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_icmp(self) -> Option<(StateGetIcmpResponder)> {
        if let StateRequest::GetIcmp { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip(self) -> Option<(StateGetIpResponder)> {
        if let StateRequest::GetIp { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_device(self) -> Option<(StateGetDeviceResponder)> {
        if let StateRequest::GetDevice { responder } = self { Some((responder)) } else { None }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            StateRequest::GetInterfaceDefaults { .. } => "get_interface_defaults",
            StateRequest::GetTcp { .. } => "get_tcp",
            StateRequest::GetUdp { .. } => "get_udp",
            StateRequest::GetIcmp { .. } => "get_icmp",
            StateRequest::GetIp { .. } => "get_ip",
            StateRequest::GetDevice { .. } => "get_device",
        }
    }
}

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

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

impl fidl::endpoints::ControlHandle for StateControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl StateControlHandle {}

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

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

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

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

    fn send_raw(
        &self,
        mut payload: &fidl_fuchsia_net_interfaces_admin::Configuration,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl_fuchsia_net_interfaces_admin::Configuration>(
            payload,
            self.tx_id,
            0x4c4824a322a705e3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

mod internal {
    use super::*;
}