fidl_fuchsia_netemul_network/

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

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

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct EndpointGetPortRequest {
    pub port: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct EndpointGetProxyRequest {
    pub proxy: fidl::endpoints::ServerEnd<DeviceProxy_Marker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct EndpointManagerCreateEndpointResponse {
    pub status: i32,
    pub endpoint: Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct EndpointManagerGetEndpointResponse {
    pub endpoint: Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NetworkContextCloneRequest {
    pub network_context: fidl::endpoints::ServerEnd<NetworkContextMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NetworkContextGetEndpointManagerRequest {
    pub endp_manager: fidl::endpoints::ServerEnd<EndpointManagerMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NetworkContextGetNetworkManagerRequest {
    pub net_manager: fidl::endpoints::ServerEnd<NetworkManagerMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NetworkContextSetupResponse {
    pub status: i32,
    pub setup_handle: Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NetworkCreateFakeEndpointRequest {
    pub ep: fidl::endpoints::ServerEnd<FakeEndpointMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NetworkManagerCreateNetworkResponse {
    pub status: i32,
    pub net: Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NetworkManagerGetNetworkResponse {
    pub net: Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
}

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

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

impl fidl::endpoints::ProtocolMarker for DeviceProxy_Marker {
    type Proxy = DeviceProxy_Proxy;
    type RequestStream = DeviceProxy_RequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DeviceProxy_SynchronousProxy;

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

pub trait DeviceProxy_ProxyInterface: Send + Sync {
    fn r#serve_controller(
        &self,
        req: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#serve_device(
        &self,
        req: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DeviceProxy_SynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DeviceProxy_SynchronousProxy {
    type Proxy = DeviceProxy_Proxy;
    type Protocol = DeviceProxy_Marker;

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

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

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

#[cfg(target_os = "fuchsia")]
impl DeviceProxy_SynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

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

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

    /// Serve the Controller protocol for this device.
    pub fn r#serve_controller(
        &self,
        mut req: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceProxyServeControllerRequest>(
            (req,),
            0x326c17ad2d3879ee,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Serve the device's FIDL protocol.
    pub fn r#serve_device(
        &self,
        mut req: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceProxyServeDeviceRequest>(
            (req,),
            0x645dae2573613288,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for DeviceProxy_Proxy {
    type Protocol = DeviceProxy_Marker;

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

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

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

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

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

    /// Serve the Controller protocol for this device.
    pub fn r#serve_controller(
        &self,
        mut req: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceProxy_ProxyInterface::r#serve_controller(self, req)
    }

    /// Serve the device's FIDL protocol.
    pub fn r#serve_device(
        &self,
        mut req: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
    ) -> Result<(), fidl::Error> {
        DeviceProxy_ProxyInterface::r#serve_device(self, req)
    }
}

impl DeviceProxy_ProxyInterface for DeviceProxy_Proxy {
    fn r#serve_controller(
        &self,
        mut req: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceProxyServeControllerRequest>(
            (req,),
            0x326c17ad2d3879ee,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#serve_device(
        &self,
        mut req: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DeviceProxyServeDeviceRequest>(
            (req,),
            0x645dae2573613288,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.netemul.network/DeviceProxy.
pub struct DeviceProxy_RequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for DeviceProxy_RequestStream {
    type Protocol = DeviceProxy_Marker;
    type ControlHandle = DeviceProxy_ControlHandle;

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

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

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

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

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

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

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

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x326c17ad2d3879ee => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceProxyServeControllerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceProxyServeControllerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceProxy_ControlHandle { inner: this.inner.clone() };
                        Ok(DeviceProxy_Request::ServeController { req: req.req, control_handle })
                    }
                    0x645dae2573613288 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DeviceProxyServeDeviceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DeviceProxyServeDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DeviceProxy_ControlHandle { inner: this.inner.clone() };
                        Ok(DeviceProxy_Request::ServeDevice { req: req.req, control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DeviceProxy_Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Simple interface to serve devices over fidl.
#[derive(Debug)]
pub enum DeviceProxy_Request {
    /// Serve the Controller protocol for this device.
    ServeController {
        req: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
        control_handle: DeviceProxy_ControlHandle,
    },
    /// Serve the device's FIDL protocol.
    ServeDevice {
        req: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
        control_handle: DeviceProxy_ControlHandle,
    },
}

impl DeviceProxy_Request {
    #[allow(irrefutable_let_patterns)]
    pub fn into_serve_controller(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
        DeviceProxy_ControlHandle,
    )> {
        if let DeviceProxy_Request::ServeController { req, control_handle } = self {
            Some((req, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_serve_device(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::DeviceInstanceMarker>,
        DeviceProxy_ControlHandle,
    )> {
        if let DeviceProxy_Request::ServeDevice { req, control_handle } = self {
            Some((req, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DeviceProxy_Request::ServeController { .. } => "serve_controller",
            DeviceProxy_Request::ServeDevice { .. } => "serve_device",
        }
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl DeviceProxy_ControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for EndpointMarker {
    type Proxy = EndpointProxy;
    type RequestStream = EndpointRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = EndpointSynchronousProxy;

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

pub trait EndpointProxyInterface: Send + Sync {
    type GetConfigResponseFut: std::future::Future<Output = Result<EndpointConfig, fidl::Error>>
        + Send;
    fn r#get_config(&self) -> Self::GetConfigResponseFut;
    type GetNameResponseFut: std::future::Future<Output = Result<String, fidl::Error>> + Send;
    fn r#get_name(&self) -> Self::GetNameResponseFut;
    type SetLinkUpResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#set_link_up(&self, up: bool) -> Self::SetLinkUpResponseFut;
    fn r#get_port(
        &self,
        port: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#get_proxy_(
        &self,
        proxy: fidl::endpoints::ServerEnd<DeviceProxy_Marker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct EndpointSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for EndpointSynchronousProxy {
    type Proxy = EndpointProxy;
    type Protocol = EndpointMarker;

    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 EndpointSynchronousProxy {
    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<EndpointEvent, fidl::Error> {
        EndpointEvent::decode(self.client.wait_for_event::<EndpointMarker>(deadline)?)
    }

    pub fn r#get_config(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EndpointConfig, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, EndpointGetConfigResponse, EndpointMarker>(
                (),
                0x3589f54aa3748539,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.config)
    }

    /// Gets endpoint name.
    pub fn r#get_name(&self, ___deadline: zx::MonotonicInstant) -> Result<String, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, EndpointGetNameResponse, EndpointMarker>(
                (),
                0x7d69650823557aab,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.name)
    }

    /// Sends link up or down signal
    pub fn r#set_link_up(
        &self,
        mut up: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<EndpointSetLinkUpRequest, fidl::encoding::EmptyPayload, EndpointMarker>(
                (up,),
                0x4dde77de68d02e11,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Connects to the underlying device port.
    pub fn r#get_port(
        &self,
        mut port: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<EndpointGetPortRequest>(
            (port,),
            0x68151e034eccc958,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Gets a proxy to open requests with zircon ethernet device.
    pub fn r#get_proxy_(
        &self,
        mut proxy: fidl::endpoints::ServerEnd<DeviceProxy_Marker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<EndpointGetProxyRequest>(
            (proxy,),
            0x476e5a57c4288ee9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for EndpointProxy {
    type Protocol = EndpointMarker;

    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 EndpointProxy {
    /// Create a new Proxy for fuchsia.netemul.network/Endpoint.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <EndpointMarker 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) -> EndpointEventStream {
        EndpointEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#get_config(
        &self,
    ) -> fidl::client::QueryResponseFut<EndpointConfig, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        EndpointProxyInterface::r#get_config(self)
    }

    /// Gets endpoint name.
    pub fn r#get_name(
        &self,
    ) -> fidl::client::QueryResponseFut<String, fidl::encoding::DefaultFuchsiaResourceDialect> {
        EndpointProxyInterface::r#get_name(self)
    }

    /// Sends link up or down signal
    pub fn r#set_link_up(
        &self,
        mut up: bool,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        EndpointProxyInterface::r#set_link_up(self, up)
    }

    /// Connects to the underlying device port.
    pub fn r#get_port(
        &self,
        mut port: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
    ) -> Result<(), fidl::Error> {
        EndpointProxyInterface::r#get_port(self, port)
    }

    /// Gets a proxy to open requests with zircon ethernet device.
    pub fn r#get_proxy_(
        &self,
        mut proxy: fidl::endpoints::ServerEnd<DeviceProxy_Marker>,
    ) -> Result<(), fidl::Error> {
        EndpointProxyInterface::r#get_proxy_(self, proxy)
    }
}

impl EndpointProxyInterface for EndpointProxy {
    type GetConfigResponseFut = fidl::client::QueryResponseFut<
        EndpointConfig,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_config(&self) -> Self::GetConfigResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EndpointConfig, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EndpointGetConfigResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3589f54aa3748539,
            >(_buf?)?;
            Ok(_response.config)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, EndpointConfig>(
            (),
            0x3589f54aa3748539,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

    fn r#get_port(
        &self,
        mut port: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<EndpointGetPortRequest>(
            (port,),
            0x68151e034eccc958,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#get_proxy_(
        &self,
        mut proxy: fidl::endpoints::ServerEnd<DeviceProxy_Marker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<EndpointGetProxyRequest>(
            (proxy,),
            0x476e5a57c4288ee9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.netemul.network/Endpoint.
pub struct EndpointRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for EndpointRequestStream {
    type Protocol = EndpointMarker;
    type ControlHandle = EndpointControlHandle;

    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 {
        EndpointControlHandle { 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 EndpointRequestStream {
    type Item = Result<EndpointRequest, 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 EndpointRequestStream 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 {
                    0x3589f54aa3748539 => {
                        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 = EndpointControlHandle { inner: this.inner.clone() };
                        Ok(EndpointRequest::GetConfig {
                            responder: EndpointGetConfigResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7d69650823557aab => {
                        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 = EndpointControlHandle { inner: this.inner.clone() };
                        Ok(EndpointRequest::GetName {
                            responder: EndpointGetNameResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4dde77de68d02e11 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            EndpointSetLinkUpRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EndpointSetLinkUpRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = EndpointControlHandle { inner: this.inner.clone() };
                        Ok(EndpointRequest::SetLinkUp {
                            up: req.up,

                            responder: EndpointSetLinkUpResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x68151e034eccc958 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            EndpointGetPortRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EndpointGetPortRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = EndpointControlHandle { inner: this.inner.clone() };
                        Ok(EndpointRequest::GetPort { port: req.port, control_handle })
                    }
                    0x476e5a57c4288ee9 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            EndpointGetProxyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EndpointGetProxyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = EndpointControlHandle { inner: this.inner.clone() };
                        Ok(EndpointRequest::GetProxy_ { proxy: req.proxy, control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <EndpointMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Virtual ethernet endpoint.
#[derive(Debug)]
pub enum EndpointRequest {
    GetConfig {
        responder: EndpointGetConfigResponder,
    },
    /// Gets endpoint name.
    GetName {
        responder: EndpointGetNameResponder,
    },
    /// Sends link up or down signal
    SetLinkUp {
        up: bool,
        responder: EndpointSetLinkUpResponder,
    },
    /// Connects to the underlying device port.
    GetPort {
        port: fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
        control_handle: EndpointControlHandle,
    },
    /// Gets a proxy to open requests with zircon ethernet device.
    GetProxy_ {
        proxy: fidl::endpoints::ServerEnd<DeviceProxy_Marker>,
        control_handle: EndpointControlHandle,
    },
}

impl EndpointRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_config(self) -> Option<(EndpointGetConfigResponder)> {
        if let EndpointRequest::GetConfig { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_name(self) -> Option<(EndpointGetNameResponder)> {
        if let EndpointRequest::GetName { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_link_up(self) -> Option<(bool, EndpointSetLinkUpResponder)> {
        if let EndpointRequest::SetLinkUp { up, responder } = self {
            Some((up, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_port(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
        EndpointControlHandle,
    )> {
        if let EndpointRequest::GetPort { port, control_handle } = self {
            Some((port, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_proxy_(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<DeviceProxy_Marker>, EndpointControlHandle)> {
        if let EndpointRequest::GetProxy_ { proxy, control_handle } = self {
            Some((proxy, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            EndpointRequest::GetConfig { .. } => "get_config",
            EndpointRequest::GetName { .. } => "get_name",
            EndpointRequest::SetLinkUp { .. } => "set_link_up",
            EndpointRequest::GetPort { .. } => "get_port",
            EndpointRequest::GetProxy_ { .. } => "get_proxy_",
        }
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl EndpointControlHandle {}

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut name: &str) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<EndpointGetNameResponse>(
            (name,),
            self.tx_id,
            0x7d69650823557aab,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for EndpointManagerMarker {
    type Proxy = EndpointManagerProxy;
    type RequestStream = EndpointManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = EndpointManagerSynchronousProxy;

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

pub trait EndpointManagerProxyInterface: Send + Sync {
    type ListEndpointsResponseFut: std::future::Future<Output = Result<Vec<String>, fidl::Error>>
        + Send;
    fn r#list_endpoints(&self) -> Self::ListEndpointsResponseFut;
    type CreateEndpointResponseFut: std::future::Future<
            Output = Result<(i32, Option<fidl::endpoints::ClientEnd<EndpointMarker>>), fidl::Error>,
        > + Send;
    fn r#create_endpoint(
        &self,
        name: &str,
        config: &EndpointConfig,
    ) -> Self::CreateEndpointResponseFut;
    type GetEndpointResponseFut: std::future::Future<
            Output = Result<Option<fidl::endpoints::ClientEnd<EndpointMarker>>, fidl::Error>,
        > + Send;
    fn r#get_endpoint(&self, name: &str) -> Self::GetEndpointResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct EndpointManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for EndpointManagerSynchronousProxy {
    type Proxy = EndpointManagerProxy;
    type Protocol = EndpointManagerMarker;

    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 EndpointManagerSynchronousProxy {
    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<EndpointManagerEvent, fidl::Error> {
        EndpointManagerEvent::decode(self.client.wait_for_event::<EndpointManagerMarker>(deadline)?)
    }

    /// Lists endpoints by name.
    pub fn r#list_endpoints(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<String>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            EndpointManagerListEndpointsResponse,
            EndpointManagerMarker,
        >(
            (),
            0x78c83d9454e3d228,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.endp)
    }

    /// Creates endpoint with given name and config.
    pub fn r#create_endpoint(
        &self,
        mut name: &str,
        mut config: &EndpointConfig,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Option<fidl::endpoints::ClientEnd<EndpointMarker>>), fidl::Error> {
        let _response = self.client.send_query::<
            EndpointManagerCreateEndpointRequest,
            EndpointManagerCreateEndpointResponse,
            EndpointManagerMarker,
        >(
            (name, config,),
            0x7defe4cd5e4e7d7c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.status, _response.endpoint))
    }

    /// Gets a handle to an endpoint.
    pub fn r#get_endpoint(
        &self,
        mut name: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Option<fidl::endpoints::ClientEnd<EndpointMarker>>, fidl::Error> {
        let _response = self.client.send_query::<
            EndpointManagerGetEndpointRequest,
            EndpointManagerGetEndpointResponse,
            EndpointManagerMarker,
        >(
            (name,),
            0x437e956b7b860751,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.endpoint)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for EndpointManagerProxy {
    type Protocol = EndpointManagerMarker;

    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 EndpointManagerProxy {
    /// Create a new Proxy for fuchsia.netemul.network/EndpointManager.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <EndpointManagerMarker 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) -> EndpointManagerEventStream {
        EndpointManagerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Lists endpoints by name.
    pub fn r#list_endpoints(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        EndpointManagerProxyInterface::r#list_endpoints(self)
    }

    /// Creates endpoint with given name and config.
    pub fn r#create_endpoint(
        &self,
        mut name: &str,
        mut config: &EndpointConfig,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<fidl::endpoints::ClientEnd<EndpointMarker>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        EndpointManagerProxyInterface::r#create_endpoint(self, name, config)
    }

    /// Gets a handle to an endpoint.
    pub fn r#get_endpoint(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<
        Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        EndpointManagerProxyInterface::r#get_endpoint(self, name)
    }
}

impl EndpointManagerProxyInterface for EndpointManagerProxy {
    type ListEndpointsResponseFut =
        fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#list_endpoints(&self) -> Self::ListEndpointsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<String>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EndpointManagerListEndpointsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x78c83d9454e3d228,
            >(_buf?)?;
            Ok(_response.endp)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<String>>(
            (),
            0x78c83d9454e3d228,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CreateEndpointResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<fidl::endpoints::ClientEnd<EndpointMarker>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_endpoint(
        &self,
        mut name: &str,
        mut config: &EndpointConfig,
    ) -> Self::CreateEndpointResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<fidl::endpoints::ClientEnd<EndpointMarker>>), fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                EndpointManagerCreateEndpointResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7defe4cd5e4e7d7c,
            >(_buf?)?;
            Ok((_response.status, _response.endpoint))
        }
        self.client.send_query_and_decode::<
            EndpointManagerCreateEndpointRequest,
            (i32, Option<fidl::endpoints::ClientEnd<EndpointMarker>>),
        >(
            (name, config,),
            0x7defe4cd5e4e7d7c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetEndpointResponseFut = fidl::client::QueryResponseFut<
        Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_endpoint(&self, mut name: &str) -> Self::GetEndpointResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Option<fidl::endpoints::ClientEnd<EndpointMarker>>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EndpointManagerGetEndpointResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x437e956b7b860751,
            >(_buf?)?;
            Ok(_response.endpoint)
        }
        self.client.send_query_and_decode::<
            EndpointManagerGetEndpointRequest,
            Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
        >(
            (name,),
            0x437e956b7b860751,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.netemul.network/EndpointManager.
pub struct EndpointManagerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for EndpointManagerRequestStream {
    type Protocol = EndpointManagerMarker;
    type ControlHandle = EndpointManagerControlHandle;

    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 {
        EndpointManagerControlHandle { 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 EndpointManagerRequestStream {
    type Item = Result<EndpointManagerRequest, 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 EndpointManagerRequestStream 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 {
                    0x78c83d9454e3d228 => {
                        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 =
                            EndpointManagerControlHandle { inner: this.inner.clone() };
                        Ok(EndpointManagerRequest::ListEndpoints {
                            responder: EndpointManagerListEndpointsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7defe4cd5e4e7d7c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            EndpointManagerCreateEndpointRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EndpointManagerCreateEndpointRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            EndpointManagerControlHandle { inner: this.inner.clone() };
                        Ok(EndpointManagerRequest::CreateEndpoint {
                            name: req.name,
                            config: req.config,

                            responder: EndpointManagerCreateEndpointResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x437e956b7b860751 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            EndpointManagerGetEndpointRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EndpointManagerGetEndpointRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            EndpointManagerControlHandle { inner: this.inner.clone() };
                        Ok(EndpointManagerRequest::GetEndpoint {
                            name: req.name,

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

/// Manages virtual endpoints.
#[derive(Debug)]
pub enum EndpointManagerRequest {
    /// Lists endpoints by name.
    ListEndpoints { responder: EndpointManagerListEndpointsResponder },
    /// Creates endpoint with given name and config.
    CreateEndpoint {
        name: String,
        config: EndpointConfig,
        responder: EndpointManagerCreateEndpointResponder,
    },
    /// Gets a handle to an endpoint.
    GetEndpoint { name: String, responder: EndpointManagerGetEndpointResponder },
}

impl EndpointManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_list_endpoints(self) -> Option<(EndpointManagerListEndpointsResponder)> {
        if let EndpointManagerRequest::ListEndpoints { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_endpoint(
        self,
    ) -> Option<(String, EndpointConfig, EndpointManagerCreateEndpointResponder)> {
        if let EndpointManagerRequest::CreateEndpoint { name, config, responder } = self {
            Some((name, config, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_endpoint(self) -> Option<(String, EndpointManagerGetEndpointResponder)> {
        if let EndpointManagerRequest::GetEndpoint { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            EndpointManagerRequest::ListEndpoints { .. } => "list_endpoints",
            EndpointManagerRequest::CreateEndpoint { .. } => "create_endpoint",
            EndpointManagerRequest::GetEndpoint { .. } => "get_endpoint",
        }
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl EndpointManagerControlHandle {}

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

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

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

    fn send_raw(&self, mut endp: &[String]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<EndpointManagerListEndpointsResponse>(
            (endp,),
            self.tx_id,
            0x78c83d9454e3d228,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

    fn control_handle(&self) -> &EndpointManagerControlHandle {
        &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 EndpointManagerCreateEndpointResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut status: i32,
        mut endpoint: Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status, endpoint);
        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 status: i32,
        mut endpoint: Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status, endpoint);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut status: i32,
        mut endpoint: Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<EndpointManagerCreateEndpointResponse>(
            (status, endpoint),
            self.tx_id,
            0x7defe4cd5e4e7d7c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut endpoint: Option<fidl::endpoints::ClientEnd<EndpointMarker>>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<EndpointManagerGetEndpointResponse>(
            (endpoint,),
            self.tx_id,
            0x437e956b7b860751,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for FakeEndpointMarker {
    type Proxy = FakeEndpointProxy;
    type RequestStream = FakeEndpointRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = FakeEndpointSynchronousProxy;

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

pub trait FakeEndpointProxyInterface: Send + Sync {
    type WriteResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#write(&self, data: &[u8]) -> Self::WriteResponseFut;
    type ReadResponseFut: std::future::Future<Output = Result<(Vec<u8>, u64), fidl::Error>> + Send;
    fn r#read(&self) -> Self::ReadResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct FakeEndpointSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for FakeEndpointSynchronousProxy {
    type Proxy = FakeEndpointProxy;
    type Protocol = FakeEndpointMarker;

    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 FakeEndpointSynchronousProxy {
    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<FakeEndpointEvent, fidl::Error> {
        FakeEndpointEvent::decode(self.client.wait_for_event::<FakeEndpointMarker>(deadline)?)
    }

    /// Writes a frame to the network.
    pub fn r#write(
        &self,
        mut data: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            FakeEndpointWriteRequest,
            fidl::encoding::EmptyPayload,
            FakeEndpointMarker,
        >(
            (data,),
            0x2c54af94338c523b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Reads a single frame from the network.
    ///
    /// Blocks until new data is available to be read. FakeEndpoint will keep a limited amount of
    /// frames to be read, dropping the oldest ones if the data is not fetched fast enough. The
    /// number of dropped frames since the last call to `Read` is returned in `dropped_frames`.
    ///
    /// Issuing a second `Read` request when the first one is still pending will cause the channel
    /// to be closed with `ZX_ERR_BAD_STATE`.
    pub fn r#read(&self, ___deadline: zx::MonotonicInstant) -> Result<(Vec<u8>, u64), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            FakeEndpointReadResponse,
            FakeEndpointMarker,
        >(
            (),
            0x58e2d032a8f36234,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.data, _response.dropped_frames))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for FakeEndpointProxy {
    type Protocol = FakeEndpointMarker;

    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 FakeEndpointProxy {
    /// Create a new Proxy for fuchsia.netemul.network/FakeEndpoint.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <FakeEndpointMarker 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) -> FakeEndpointEventStream {
        FakeEndpointEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Writes a frame to the network.
    pub fn r#write(
        &self,
        mut data: &[u8],
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        FakeEndpointProxyInterface::r#write(self, data)
    }

    /// Reads a single frame from the network.
    ///
    /// Blocks until new data is available to be read. FakeEndpoint will keep a limited amount of
    /// frames to be read, dropping the oldest ones if the data is not fetched fast enough. The
    /// number of dropped frames since the last call to `Read` is returned in `dropped_frames`.
    ///
    /// Issuing a second `Read` request when the first one is still pending will cause the channel
    /// to be closed with `ZX_ERR_BAD_STATE`.
    pub fn r#read(
        &self,
    ) -> fidl::client::QueryResponseFut<(Vec<u8>, u64), fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        FakeEndpointProxyInterface::r#read(self)
    }
}

impl FakeEndpointProxyInterface for FakeEndpointProxy {
    type WriteResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#write(&self, mut data: &[u8]) -> Self::WriteResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2c54af94338c523b,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<FakeEndpointWriteRequest, ()>(
            (data,),
            0x2c54af94338c523b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReadResponseFut = fidl::client::QueryResponseFut<
        (Vec<u8>, u64),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read(&self) -> Self::ReadResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(Vec<u8>, u64), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                FakeEndpointReadResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x58e2d032a8f36234,
            >(_buf?)?;
            Ok((_response.data, _response.dropped_frames))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, (Vec<u8>, u64)>(
            (),
            0x58e2d032a8f36234,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.netemul.network/FakeEndpoint.
pub struct FakeEndpointRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for FakeEndpointRequestStream {
    type Protocol = FakeEndpointMarker;
    type ControlHandle = FakeEndpointControlHandle;

    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 {
        FakeEndpointControlHandle { 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 FakeEndpointRequestStream {
    type Item = Result<FakeEndpointRequest, 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 FakeEndpointRequestStream 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 {
                    0x2c54af94338c523b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FakeEndpointWriteRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FakeEndpointWriteRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            FakeEndpointControlHandle { inner: this.inner.clone() };
                        Ok(FakeEndpointRequest::Write {
                            data: req.data,

                            responder: FakeEndpointWriteResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x58e2d032a8f36234 => {
                        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 =
                            FakeEndpointControlHandle { inner: this.inner.clone() };
                        Ok(FakeEndpointRequest::Read {
                            responder: FakeEndpointReadResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <FakeEndpointMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Fake endpoint can be added to a network to snoop or inject packets.
#[derive(Debug)]
pub enum FakeEndpointRequest {
    /// Writes a frame to the network.
    Write { data: Vec<u8>, responder: FakeEndpointWriteResponder },
    /// Reads a single frame from the network.
    ///
    /// Blocks until new data is available to be read. FakeEndpoint will keep a limited amount of
    /// frames to be read, dropping the oldest ones if the data is not fetched fast enough. The
    /// number of dropped frames since the last call to `Read` is returned in `dropped_frames`.
    ///
    /// Issuing a second `Read` request when the first one is still pending will cause the channel
    /// to be closed with `ZX_ERR_BAD_STATE`.
    Read { responder: FakeEndpointReadResponder },
}

impl FakeEndpointRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_write(self) -> Option<(Vec<u8>, FakeEndpointWriteResponder)> {
        if let FakeEndpointRequest::Write { data, responder } = self {
            Some((data, responder))
        } else {
            None
        }
    }

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

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            FakeEndpointRequest::Write { .. } => "write",
            FakeEndpointRequest::Read { .. } => "read",
        }
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl FakeEndpointControlHandle {}

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut data: &[u8], mut dropped_frames: u64) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<FakeEndpointReadResponse>(
            (data, dropped_frames),
            self.tx_id,
            0x58e2d032a8f36234,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for NetworkMarker {
    type Proxy = NetworkProxy;
    type RequestStream = NetworkRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = NetworkSynchronousProxy;

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

pub trait NetworkProxyInterface: Send + Sync {
    fn r#add_port(
        &self,
        port: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_network::PortMarker>,
        interface: fidl::endpoints::ServerEnd<fidl_fuchsia_net_virtualization::InterfaceMarker>,
    ) -> Result<(), fidl::Error>;
    type GetConfigResponseFut: std::future::Future<Output = Result<NetworkConfig, fidl::Error>>
        + Send;
    fn r#get_config(&self) -> Self::GetConfigResponseFut;
    type GetNameResponseFut: std::future::Future<Output = Result<String, fidl::Error>> + Send;
    fn r#get_name(&self) -> Self::GetNameResponseFut;
    type SetConfigResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#set_config(&self, config: &NetworkConfig) -> Self::SetConfigResponseFut;
    type AttachEndpointResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#attach_endpoint(&self, name: &str) -> Self::AttachEndpointResponseFut;
    type RemoveEndpointResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#remove_endpoint(&self, name: &str) -> Self::RemoveEndpointResponseFut;
    fn r#create_fake_endpoint(
        &self,
        ep: fidl::endpoints::ServerEnd<FakeEndpointMarker>,
    ) -> Result<(), fidl::Error>;
    type StartCaptureResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
    fn r#start_capture(&self, name: &str) -> Self::StartCaptureResponseFut;
    type StopCaptureResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#stop_capture(&self) -> Self::StopCaptureResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct NetworkSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for NetworkSynchronousProxy {
    type Proxy = NetworkProxy;
    type Protocol = NetworkMarker;

    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 NetworkSynchronousProxy {
    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<NetworkEvent, fidl::Error> {
        NetworkEvent::decode(self.client.wait_for_event::<NetworkMarker>(deadline)?)
    }

    /// Adds a port to the network.
    ///
    /// + request `port` port to be added.
    /// + request `interface` provides control over the interface.
    pub fn r#add_port(
        &self,
        mut port: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_network::PortMarker>,
        mut interface: fidl::endpoints::ServerEnd<fidl_fuchsia_net_virtualization::InterfaceMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_net_virtualization::NetworkAddPortRequest>(
            (port, interface),
            0x7ad6a60c931a3f4e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Gets network configuration.
    pub fn r#get_config(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NetworkConfig, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, NetworkGetConfigResponse, NetworkMarker>(
                (),
                0x8dc04557e2ab069,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.config)
    }

    /// Gets network name.
    pub fn r#get_name(&self, ___deadline: zx::MonotonicInstant) -> Result<String, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, NetworkGetNameResponse, NetworkMarker>(
                (),
                0x57b7701d1ffeedb1,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.name)
    }

    /// Updates network configuration.
    pub fn r#set_config(
        &self,
        mut config: &NetworkConfig,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self
            .client
            .send_query::<NetworkSetConfigRequest, NetworkSetConfigResponse, NetworkMarker>(
                (config,),
                0x18a490ee9d4bfa16,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Attaches endpoint with given name to network.
    pub fn r#attach_endpoint(
        &self,
        mut name: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            NetworkAttachEndpointRequest,
            NetworkAttachEndpointResponse,
            NetworkMarker,
        >(
            (name,),
            0x6e8ff8e9ea1b9a98,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Removes endpoint with given name from network.
    pub fn r#remove_endpoint(
        &self,
        mut name: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            NetworkRemoveEndpointRequest,
            NetworkRemoveEndpointResponse,
            NetworkMarker,
        >(
            (name,),
            0x298eaac56bfcdd25,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Injects a fake endpoint.
    pub fn r#create_fake_endpoint(
        &self,
        mut ep: fidl::endpoints::ServerEnd<FakeEndpointMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NetworkCreateFakeEndpointRequest>(
            (ep,),
            0x3eb8f71b45e1e1f3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Starts capturing packet in this network.
    ///
    /// The packet capture will be stored at `/custom_artifacts/{name}.pcapng`.
    ///
    /// Returns [`ZX_ERR_ALREADY_EXISTS`] if the capturing is already started
    /// in this network.
    pub fn r#start_capture(
        &self,
        mut name: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self
            .client
            .send_query::<NetworkStartCaptureRequest, NetworkStartCaptureResponse, NetworkMarker>(
                (name,),
                0x3ca44940622932c,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.status)
    }

    /// Stops capturing packets. This function is guaranteed to succeed.
    ///
    /// The packet capture will be stored in the file at the path chosen when
    /// capturing started. The packet capture will stop automatically once the
    /// network is destroyed regardless of whether this method is called.
    pub fn r#stop_capture(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::EmptyPayload,
            NetworkMarker,
        >(
            (),
            0x1d7827adad109468,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for NetworkProxy {
    type Protocol = NetworkMarker;

    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 NetworkProxy {
    /// Create a new Proxy for fuchsia.netemul.network/Network.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <NetworkMarker 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) -> NetworkEventStream {
        NetworkEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Adds a port to the network.
    ///
    /// + request `port` port to be added.
    /// + request `interface` provides control over the interface.
    pub fn r#add_port(
        &self,
        mut port: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_network::PortMarker>,
        mut interface: fidl::endpoints::ServerEnd<fidl_fuchsia_net_virtualization::InterfaceMarker>,
    ) -> Result<(), fidl::Error> {
        NetworkProxyInterface::r#add_port(self, port, interface)
    }

    /// Gets network configuration.
    pub fn r#get_config(
        &self,
    ) -> fidl::client::QueryResponseFut<NetworkConfig, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        NetworkProxyInterface::r#get_config(self)
    }

    /// Gets network name.
    pub fn r#get_name(
        &self,
    ) -> fidl::client::QueryResponseFut<String, fidl::encoding::DefaultFuchsiaResourceDialect> {
        NetworkProxyInterface::r#get_name(self)
    }

    /// Updates network configuration.
    pub fn r#set_config(
        &self,
        mut config: &NetworkConfig,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        NetworkProxyInterface::r#set_config(self, config)
    }

    /// Attaches endpoint with given name to network.
    pub fn r#attach_endpoint(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        NetworkProxyInterface::r#attach_endpoint(self, name)
    }

    /// Removes endpoint with given name from network.
    pub fn r#remove_endpoint(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        NetworkProxyInterface::r#remove_endpoint(self, name)
    }

    /// Injects a fake endpoint.
    pub fn r#create_fake_endpoint(
        &self,
        mut ep: fidl::endpoints::ServerEnd<FakeEndpointMarker>,
    ) -> Result<(), fidl::Error> {
        NetworkProxyInterface::r#create_fake_endpoint(self, ep)
    }

    /// Starts capturing packet in this network.
    ///
    /// The packet capture will be stored at `/custom_artifacts/{name}.pcapng`.
    ///
    /// Returns [`ZX_ERR_ALREADY_EXISTS`] if the capturing is already started
    /// in this network.
    pub fn r#start_capture(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        NetworkProxyInterface::r#start_capture(self, name)
    }

    /// Stops capturing packets. This function is guaranteed to succeed.
    ///
    /// The packet capture will be stored in the file at the path chosen when
    /// capturing started. The packet capture will stop automatically once the
    /// network is destroyed regardless of whether this method is called.
    pub fn r#stop_capture(
        &self,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        NetworkProxyInterface::r#stop_capture(self)
    }
}

impl NetworkProxyInterface for NetworkProxy {
    fn r#add_port(
        &self,
        mut port: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_network::PortMarker>,
        mut interface: fidl::endpoints::ServerEnd<fidl_fuchsia_net_virtualization::InterfaceMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_net_virtualization::NetworkAddPortRequest>(
            (port, interface),
            0x7ad6a60c931a3f4e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

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

    type SetConfigResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_config(&self, mut config: &NetworkConfig) -> Self::SetConfigResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NetworkSetConfigResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x18a490ee9d4bfa16,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<NetworkSetConfigRequest, i32>(
            (config,),
            0x18a490ee9d4bfa16,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AttachEndpointResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#attach_endpoint(&self, mut name: &str) -> Self::AttachEndpointResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NetworkAttachEndpointResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6e8ff8e9ea1b9a98,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<NetworkAttachEndpointRequest, i32>(
            (name,),
            0x6e8ff8e9ea1b9a98,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RemoveEndpointResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#remove_endpoint(&self, mut name: &str) -> Self::RemoveEndpointResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NetworkRemoveEndpointResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x298eaac56bfcdd25,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<NetworkRemoveEndpointRequest, i32>(
            (name,),
            0x298eaac56bfcdd25,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#create_fake_endpoint(
        &self,
        mut ep: fidl::endpoints::ServerEnd<FakeEndpointMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NetworkCreateFakeEndpointRequest>(
            (ep,),
            0x3eb8f71b45e1e1f3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type StartCaptureResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#start_capture(&self, mut name: &str) -> Self::StartCaptureResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NetworkStartCaptureResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3ca44940622932c,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<NetworkStartCaptureRequest, i32>(
            (name,),
            0x3ca44940622932c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

#[derive(Debug)]
pub enum NetworkEvent {
    OnRemoved { reason: fidl_fuchsia_net_virtualization::NetworkRemovalReason },
}

impl NetworkEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_removed(self) -> Option<fidl_fuchsia_net_virtualization::NetworkRemovalReason> {
        if let NetworkEvent::OnRemoved { reason } = self { Some((reason)) } else { None }
    }

    /// Decodes a message buffer as a [`NetworkEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<NetworkEvent, 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 {
            0xfe80656d1e5ec4a => {
                let mut out = fidl::new_empty!(
                    fidl_fuchsia_net_virtualization::NetworkOnRemovedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_net_virtualization::NetworkOnRemovedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((NetworkEvent::OnRemoved { reason: out.reason }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <NetworkMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.netemul.network/Network.
pub struct NetworkRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for NetworkRequestStream {
    type Protocol = NetworkMarker;
    type ControlHandle = NetworkControlHandle;

    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 {
        NetworkControlHandle { 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 NetworkRequestStream {
    type Item = Result<NetworkRequest, 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 NetworkRequestStream 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 {
                    0x7ad6a60c931a3f4e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl_fuchsia_net_virtualization::NetworkAddPortRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_net_virtualization::NetworkAddPortRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NetworkControlHandle { inner: this.inner.clone() };
                        Ok(NetworkRequest::AddPort {
                            port: req.port,
                            interface: req.interface,

                            control_handle,
                        })
                    }
                    0x8dc04557e2ab069 => {
                        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 = NetworkControlHandle { inner: this.inner.clone() };
                        Ok(NetworkRequest::GetConfig {
                            responder: NetworkGetConfigResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x57b7701d1ffeedb1 => {
                        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 = NetworkControlHandle { inner: this.inner.clone() };
                        Ok(NetworkRequest::GetName {
                            responder: NetworkGetNameResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x18a490ee9d4bfa16 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NetworkSetConfigRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkSetConfigRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NetworkControlHandle { inner: this.inner.clone() };
                        Ok(NetworkRequest::SetConfig {
                            config: req.config,

                            responder: NetworkSetConfigResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e8ff8e9ea1b9a98 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NetworkAttachEndpointRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkAttachEndpointRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NetworkControlHandle { inner: this.inner.clone() };
                        Ok(NetworkRequest::AttachEndpoint {
                            name: req.name,

                            responder: NetworkAttachEndpointResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x298eaac56bfcdd25 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NetworkRemoveEndpointRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkRemoveEndpointRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NetworkControlHandle { inner: this.inner.clone() };
                        Ok(NetworkRequest::RemoveEndpoint {
                            name: req.name,

                            responder: NetworkRemoveEndpointResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3eb8f71b45e1e1f3 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NetworkCreateFakeEndpointRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkCreateFakeEndpointRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NetworkControlHandle { inner: this.inner.clone() };
                        Ok(NetworkRequest::CreateFakeEndpoint { ep: req.ep, control_handle })
                    }
                    0x3ca44940622932c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NetworkStartCaptureRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkStartCaptureRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = NetworkControlHandle { inner: this.inner.clone() };
                        Ok(NetworkRequest::StartCapture {
                            name: req.name,

                            responder: NetworkStartCaptureResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1d7827adad109468 => {
                        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 = NetworkControlHandle { inner: this.inner.clone() };
                        Ok(NetworkRequest::StopCapture {
                            responder: NetworkStopCaptureResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <NetworkMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Virtual network.
#[derive(Debug)]
pub enum NetworkRequest {
    /// Adds a port to the network.
    ///
    /// + request `port` port to be added.
    /// + request `interface` provides control over the interface.
    AddPort {
        port: fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_network::PortMarker>,
        interface: fidl::endpoints::ServerEnd<fidl_fuchsia_net_virtualization::InterfaceMarker>,
        control_handle: NetworkControlHandle,
    },
    /// Gets network configuration.
    GetConfig { responder: NetworkGetConfigResponder },
    /// Gets network name.
    GetName { responder: NetworkGetNameResponder },
    /// Updates network configuration.
    SetConfig { config: NetworkConfig, responder: NetworkSetConfigResponder },
    /// Attaches endpoint with given name to network.
    AttachEndpoint { name: String, responder: NetworkAttachEndpointResponder },
    /// Removes endpoint with given name from network.
    RemoveEndpoint { name: String, responder: NetworkRemoveEndpointResponder },
    /// Injects a fake endpoint.
    CreateFakeEndpoint {
        ep: fidl::endpoints::ServerEnd<FakeEndpointMarker>,
        control_handle: NetworkControlHandle,
    },
    /// Starts capturing packet in this network.
    ///
    /// The packet capture will be stored at `/custom_artifacts/{name}.pcapng`.
    ///
    /// Returns [`ZX_ERR_ALREADY_EXISTS`] if the capturing is already started
    /// in this network.
    StartCapture { name: String, responder: NetworkStartCaptureResponder },
    /// Stops capturing packets. This function is guaranteed to succeed.
    ///
    /// The packet capture will be stored in the file at the path chosen when
    /// capturing started. The packet capture will stop automatically once the
    /// network is destroyed regardless of whether this method is called.
    StopCapture { responder: NetworkStopCaptureResponder },
}

impl NetworkRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_add_port(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<fidl_fuchsia_hardware_network::PortMarker>,
        fidl::endpoints::ServerEnd<fidl_fuchsia_net_virtualization::InterfaceMarker>,
        NetworkControlHandle,
    )> {
        if let NetworkRequest::AddPort { port, interface, control_handle } = self {
            Some((port, interface, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_config(self) -> Option<(NetworkGetConfigResponder)> {
        if let NetworkRequest::GetConfig { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_name(self) -> Option<(NetworkGetNameResponder)> {
        if let NetworkRequest::GetName { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_config(self) -> Option<(NetworkConfig, NetworkSetConfigResponder)> {
        if let NetworkRequest::SetConfig { config, responder } = self {
            Some((config, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_attach_endpoint(self) -> Option<(String, NetworkAttachEndpointResponder)> {
        if let NetworkRequest::AttachEndpoint { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_endpoint(self) -> Option<(String, NetworkRemoveEndpointResponder)> {
        if let NetworkRequest::RemoveEndpoint { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_fake_endpoint(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<FakeEndpointMarker>, NetworkControlHandle)> {
        if let NetworkRequest::CreateFakeEndpoint { ep, control_handle } = self {
            Some((ep, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start_capture(self) -> Option<(String, NetworkStartCaptureResponder)> {
        if let NetworkRequest::StartCapture { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop_capture(self) -> Option<(NetworkStopCaptureResponder)> {
        if let NetworkRequest::StopCapture { responder } = self { Some((responder)) } else { None }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            NetworkRequest::AddPort { .. } => "add_port",
            NetworkRequest::GetConfig { .. } => "get_config",
            NetworkRequest::GetName { .. } => "get_name",
            NetworkRequest::SetConfig { .. } => "set_config",
            NetworkRequest::AttachEndpoint { .. } => "attach_endpoint",
            NetworkRequest::RemoveEndpoint { .. } => "remove_endpoint",
            NetworkRequest::CreateFakeEndpoint { .. } => "create_fake_endpoint",
            NetworkRequest::StartCapture { .. } => "start_capture",
            NetworkRequest::StopCapture { .. } => "stop_capture",
        }
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl NetworkControlHandle {
    pub fn send_on_removed(
        &self,
        mut reason: fidl_fuchsia_net_virtualization::NetworkRemovalReason,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<fidl_fuchsia_net_virtualization::NetworkOnRemovedRequest>(
            (reason,),
            0,
            0xfe80656d1e5ec4a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut name: &str) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NetworkGetNameResponse>(
            (name,),
            self.tx_id,
            0x57b7701d1ffeedb1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NetworkSetConfigResponse>(
            (status,),
            self.tx_id,
            0x18a490ee9d4bfa16,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NetworkAttachEndpointResponse>(
            (status,),
            self.tx_id,
            0x6e8ff8e9ea1b9a98,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NetworkRemoveEndpointResponse>(
            (status,),
            self.tx_id,
            0x298eaac56bfcdd25,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NetworkStartCaptureResponse>(
            (status,),
            self.tx_id,
            0x3ca44940622932c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for NetworkContextMarker {
    type Proxy = NetworkContextProxy;
    type RequestStream = NetworkContextRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = NetworkContextSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.netemul.network.NetworkContext";
}
impl fidl::endpoints::DiscoverableProtocolMarker for NetworkContextMarker {}

pub trait NetworkContextProxyInterface: Send + Sync {
    fn r#clone(
        &self,
        network_context: fidl::endpoints::ServerEnd<NetworkContextMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#get_network_manager(
        &self,
        net_manager: fidl::endpoints::ServerEnd<NetworkManagerMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#get_endpoint_manager(
        &self,
        endp_manager: fidl::endpoints::ServerEnd<EndpointManagerMarker>,
    ) -> Result<(), fidl::Error>;
    type SetupResponseFut: std::future::Future<
            Output = Result<
                (i32, Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>),
                fidl::Error,
            >,
        > + Send;
    fn r#setup(&self, networks: &[NetworkSetup]) -> Self::SetupResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct NetworkContextSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for NetworkContextSynchronousProxy {
    type Proxy = NetworkContextProxy;
    type Protocol = NetworkContextMarker;

    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 NetworkContextSynchronousProxy {
    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<NetworkContextEvent, fidl::Error> {
        NetworkContextEvent::decode(self.client.wait_for_event::<NetworkContextMarker>(deadline)?)
    }

    pub fn r#clone(
        &self,
        mut network_context: fidl::endpoints::ServerEnd<NetworkContextMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NetworkContextCloneRequest>(
            (network_context,),
            0x1f7eb1b78a2ad2b0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#get_network_manager(
        &self,
        mut net_manager: fidl::endpoints::ServerEnd<NetworkManagerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NetworkContextGetNetworkManagerRequest>(
            (net_manager,),
            0x379899a30766afd4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#get_endpoint_manager(
        &self,
        mut endp_manager: fidl::endpoints::ServerEnd<EndpointManagerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NetworkContextGetEndpointManagerRequest>(
            (endp_manager,),
            0x5e64360363b9bd81,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Creates a collection of networks described by `networks`.
    /// `status` is `ZX_OK` for success
    /// `setup_handle` is a resource that references and maintains the lifecycle of
    ///                the created networks and endpoints.
    pub fn r#setup(
        &self,
        mut networks: &[NetworkSetup],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>), fidl::Error> {
        let _response = self.client.send_query::<
            NetworkContextSetupRequest,
            NetworkContextSetupResponse,
            NetworkContextMarker,
        >(
            (networks,),
            0x1680e0b13823fc8c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.status, _response.setup_handle))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for NetworkContextProxy {
    type Protocol = NetworkContextMarker;

    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 NetworkContextProxy {
    /// Create a new Proxy for fuchsia.netemul.network/NetworkContext.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <NetworkContextMarker 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) -> NetworkContextEventStream {
        NetworkContextEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#clone(
        &self,
        mut network_context: fidl::endpoints::ServerEnd<NetworkContextMarker>,
    ) -> Result<(), fidl::Error> {
        NetworkContextProxyInterface::r#clone(self, network_context)
    }

    pub fn r#get_network_manager(
        &self,
        mut net_manager: fidl::endpoints::ServerEnd<NetworkManagerMarker>,
    ) -> Result<(), fidl::Error> {
        NetworkContextProxyInterface::r#get_network_manager(self, net_manager)
    }

    pub fn r#get_endpoint_manager(
        &self,
        mut endp_manager: fidl::endpoints::ServerEnd<EndpointManagerMarker>,
    ) -> Result<(), fidl::Error> {
        NetworkContextProxyInterface::r#get_endpoint_manager(self, endp_manager)
    }

    /// Creates a collection of networks described by `networks`.
    /// `status` is `ZX_OK` for success
    /// `setup_handle` is a resource that references and maintains the lifecycle of
    ///                the created networks and endpoints.
    pub fn r#setup(
        &self,
        mut networks: &[NetworkSetup],
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NetworkContextProxyInterface::r#setup(self, networks)
    }
}

impl NetworkContextProxyInterface for NetworkContextProxy {
    fn r#clone(
        &self,
        mut network_context: fidl::endpoints::ServerEnd<NetworkContextMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NetworkContextCloneRequest>(
            (network_context,),
            0x1f7eb1b78a2ad2b0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#get_network_manager(
        &self,
        mut net_manager: fidl::endpoints::ServerEnd<NetworkManagerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NetworkContextGetNetworkManagerRequest>(
            (net_manager,),
            0x379899a30766afd4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#get_endpoint_manager(
        &self,
        mut endp_manager: fidl::endpoints::ServerEnd<EndpointManagerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<NetworkContextGetEndpointManagerRequest>(
            (endp_manager,),
            0x5e64360363b9bd81,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type SetupResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#setup(&self, mut networks: &[NetworkSetup]) -> Self::SetupResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>), fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                NetworkContextSetupResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1680e0b13823fc8c,
            >(_buf?)?;
            Ok((_response.status, _response.setup_handle))
        }
        self.client.send_query_and_decode::<
            NetworkContextSetupRequest,
            (i32, Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>),
        >(
            (networks,),
            0x1680e0b13823fc8c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.netemul.network/NetworkContext.
pub struct NetworkContextRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for NetworkContextRequestStream {
    type Protocol = NetworkContextMarker;
    type ControlHandle = NetworkContextControlHandle;

    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 {
        NetworkContextControlHandle { 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 NetworkContextRequestStream {
    type Item = Result<NetworkContextRequest, 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 NetworkContextRequestStream 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 {
                    0x1f7eb1b78a2ad2b0 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NetworkContextCloneRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkContextCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            NetworkContextControlHandle { inner: this.inner.clone() };
                        Ok(NetworkContextRequest::Clone {
                            network_context: req.network_context,

                            control_handle,
                        })
                    }
                    0x379899a30766afd4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NetworkContextGetNetworkManagerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkContextGetNetworkManagerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            NetworkContextControlHandle { inner: this.inner.clone() };
                        Ok(NetworkContextRequest::GetNetworkManager {
                            net_manager: req.net_manager,

                            control_handle,
                        })
                    }
                    0x5e64360363b9bd81 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NetworkContextGetEndpointManagerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkContextGetEndpointManagerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            NetworkContextControlHandle { inner: this.inner.clone() };
                        Ok(NetworkContextRequest::GetEndpointManager {
                            endp_manager: req.endp_manager,

                            control_handle,
                        })
                    }
                    0x1680e0b13823fc8c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NetworkContextSetupRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkContextSetupRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            NetworkContextControlHandle { inner: this.inner.clone() };
                        Ok(NetworkContextRequest::Setup {
                            networks: req.networks,

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

/// Main entry point to manage virtual networks and endpoints.
///
/// Every new connection to NetworkContext provides access to a an isolated
/// namespace for networks and endpoints. `Clone` is the only means by which a
/// client can acquire a new connection to the same network context.
#[derive(Debug)]
pub enum NetworkContextRequest {
    Clone {
        network_context: fidl::endpoints::ServerEnd<NetworkContextMarker>,
        control_handle: NetworkContextControlHandle,
    },
    GetNetworkManager {
        net_manager: fidl::endpoints::ServerEnd<NetworkManagerMarker>,
        control_handle: NetworkContextControlHandle,
    },
    GetEndpointManager {
        endp_manager: fidl::endpoints::ServerEnd<EndpointManagerMarker>,
        control_handle: NetworkContextControlHandle,
    },
    /// Creates a collection of networks described by `networks`.
    /// `status` is `ZX_OK` for success
    /// `setup_handle` is a resource that references and maintains the lifecycle of
    ///                the created networks and endpoints.
    Setup { networks: Vec<NetworkSetup>, responder: NetworkContextSetupResponder },
}

impl NetworkContextRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_clone(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<NetworkContextMarker>, NetworkContextControlHandle)>
    {
        if let NetworkContextRequest::Clone { network_context, control_handle } = self {
            Some((network_context, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_network_manager(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<NetworkManagerMarker>, NetworkContextControlHandle)>
    {
        if let NetworkContextRequest::GetNetworkManager { net_manager, control_handle } = self {
            Some((net_manager, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_endpoint_manager(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<EndpointManagerMarker>, NetworkContextControlHandle)>
    {
        if let NetworkContextRequest::GetEndpointManager { endp_manager, control_handle } = self {
            Some((endp_manager, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_setup(self) -> Option<(Vec<NetworkSetup>, NetworkContextSetupResponder)> {
        if let NetworkContextRequest::Setup { networks, responder } = self {
            Some((networks, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            NetworkContextRequest::Clone { .. } => "clone",
            NetworkContextRequest::GetNetworkManager { .. } => "get_network_manager",
            NetworkContextRequest::GetEndpointManager { .. } => "get_endpoint_manager",
            NetworkContextRequest::Setup { .. } => "setup",
        }
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl NetworkContextControlHandle {}

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

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

    fn control_handle(&self) -> &NetworkContextControlHandle {
        &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 NetworkContextSetupResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut status: i32,
        mut setup_handle: Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status, setup_handle);
        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 status: i32,
        mut setup_handle: Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status, setup_handle);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut status: i32,
        mut setup_handle: Option<fidl::endpoints::ClientEnd<SetupHandleMarker>>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NetworkContextSetupResponse>(
            (status, setup_handle),
            self.tx_id,
            0x1680e0b13823fc8c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for NetworkManagerMarker {
    type Proxy = NetworkManagerProxy;
    type RequestStream = NetworkManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = NetworkManagerSynchronousProxy;

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

pub trait NetworkManagerProxyInterface: Send + Sync {
    type ListNetworksResponseFut: std::future::Future<Output = Result<Vec<String>, fidl::Error>>
        + Send;
    fn r#list_networks(&self) -> Self::ListNetworksResponseFut;
    type CreateNetworkResponseFut: std::future::Future<
            Output = Result<(i32, Option<fidl::endpoints::ClientEnd<NetworkMarker>>), fidl::Error>,
        > + Send;
    fn r#create_network(
        &self,
        name: &str,
        config: &NetworkConfig,
    ) -> Self::CreateNetworkResponseFut;
    type GetNetworkResponseFut: std::future::Future<
            Output = Result<Option<fidl::endpoints::ClientEnd<NetworkMarker>>, fidl::Error>,
        > + Send;
    fn r#get_network(&self, name: &str) -> Self::GetNetworkResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct NetworkManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for NetworkManagerSynchronousProxy {
    type Proxy = NetworkManagerProxy;
    type Protocol = NetworkManagerMarker;

    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 NetworkManagerSynchronousProxy {
    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<NetworkManagerEvent, fidl::Error> {
        NetworkManagerEvent::decode(self.client.wait_for_event::<NetworkManagerMarker>(deadline)?)
    }

    /// Lists emulated networks by name.
    pub fn r#list_networks(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<String>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            NetworkManagerListNetworksResponse,
            NetworkManagerMarker,
        >(
            (),
            0x2488653e0974cc62,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.nets)
    }

    /// Creates a new network with given name and config.
    pub fn r#create_network(
        &self,
        mut name: &str,
        mut config: &NetworkConfig,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(i32, Option<fidl::endpoints::ClientEnd<NetworkMarker>>), fidl::Error> {
        let _response = self.client.send_query::<
            NetworkManagerCreateNetworkRequest,
            NetworkManagerCreateNetworkResponse,
            NetworkManagerMarker,
        >(
            (name, config,),
            0x6052eb5ac709af,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok((_response.status, _response.net))
    }

    /// Gets a handle to a network.
    pub fn r#get_network(
        &self,
        mut name: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Option<fidl::endpoints::ClientEnd<NetworkMarker>>, fidl::Error> {
        let _response = self.client.send_query::<
            NetworkManagerGetNetworkRequest,
            NetworkManagerGetNetworkResponse,
            NetworkManagerMarker,
        >(
            (name,),
            0x59930bf23acc7d9a,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.net)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for NetworkManagerProxy {
    type Protocol = NetworkManagerMarker;

    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 NetworkManagerProxy {
    /// Create a new Proxy for fuchsia.netemul.network/NetworkManager.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <NetworkManagerMarker 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) -> NetworkManagerEventStream {
        NetworkManagerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Lists emulated networks by name.
    pub fn r#list_networks(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        NetworkManagerProxyInterface::r#list_networks(self)
    }

    /// Creates a new network with given name and config.
    pub fn r#create_network(
        &self,
        mut name: &str,
        mut config: &NetworkConfig,
    ) -> fidl::client::QueryResponseFut<
        (i32, Option<fidl::endpoints::ClientEnd<NetworkMarker>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NetworkManagerProxyInterface::r#create_network(self, name, config)
    }

    /// Gets a handle to a network.
    pub fn r#get_network(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<
        Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NetworkManagerProxyInterface::r#get_network(self, name)
    }
}

impl NetworkManagerProxyInterface for NetworkManagerProxy {
    type ListNetworksResponseFut =
        fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#list_networks(&self) -> Self::ListNetworksResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<String>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NetworkManagerListNetworksResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2488653e0974cc62,
            >(_buf?)?;
            Ok(_response.nets)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<String>>(
            (),
            0x2488653e0974cc62,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CreateNetworkResponseFut = fidl::client::QueryResponseFut<
        (i32, Option<fidl::endpoints::ClientEnd<NetworkMarker>>),
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_network(
        &self,
        mut name: &str,
        mut config: &NetworkConfig,
    ) -> Self::CreateNetworkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(i32, Option<fidl::endpoints::ClientEnd<NetworkMarker>>), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NetworkManagerCreateNetworkResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6052eb5ac709af,
            >(_buf?)?;
            Ok((_response.status, _response.net))
        }
        self.client.send_query_and_decode::<
            NetworkManagerCreateNetworkRequest,
            (i32, Option<fidl::endpoints::ClientEnd<NetworkMarker>>),
        >(
            (name, config,),
            0x6052eb5ac709af,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetNetworkResponseFut = fidl::client::QueryResponseFut<
        Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_network(&self, mut name: &str) -> Self::GetNetworkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Option<fidl::endpoints::ClientEnd<NetworkMarker>>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NetworkManagerGetNetworkResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x59930bf23acc7d9a,
            >(_buf?)?;
            Ok(_response.net)
        }
        self.client.send_query_and_decode::<
            NetworkManagerGetNetworkRequest,
            Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
        >(
            (name,),
            0x59930bf23acc7d9a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.netemul.network/NetworkManager.
pub struct NetworkManagerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for NetworkManagerRequestStream {
    type Protocol = NetworkManagerMarker;
    type ControlHandle = NetworkManagerControlHandle;

    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 {
        NetworkManagerControlHandle { 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 NetworkManagerRequestStream {
    type Item = Result<NetworkManagerRequest, 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 NetworkManagerRequestStream 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 {
                    0x2488653e0974cc62 => {
                        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 =
                            NetworkManagerControlHandle { inner: this.inner.clone() };
                        Ok(NetworkManagerRequest::ListNetworks {
                            responder: NetworkManagerListNetworksResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6052eb5ac709af => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NetworkManagerCreateNetworkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkManagerCreateNetworkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            NetworkManagerControlHandle { inner: this.inner.clone() };
                        Ok(NetworkManagerRequest::CreateNetwork {
                            name: req.name,
                            config: req.config,

                            responder: NetworkManagerCreateNetworkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x59930bf23acc7d9a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NetworkManagerGetNetworkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NetworkManagerGetNetworkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            NetworkManagerControlHandle { inner: this.inner.clone() };
                        Ok(NetworkManagerRequest::GetNetwork {
                            name: req.name,

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

/// Manages virtual networks.
#[derive(Debug)]
pub enum NetworkManagerRequest {
    /// Lists emulated networks by name.
    ListNetworks { responder: NetworkManagerListNetworksResponder },
    /// Creates a new network with given name and config.
    CreateNetwork {
        name: String,
        config: NetworkConfig,
        responder: NetworkManagerCreateNetworkResponder,
    },
    /// Gets a handle to a network.
    GetNetwork { name: String, responder: NetworkManagerGetNetworkResponder },
}

impl NetworkManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_list_networks(self) -> Option<(NetworkManagerListNetworksResponder)> {
        if let NetworkManagerRequest::ListNetworks { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_network(
        self,
    ) -> Option<(String, NetworkConfig, NetworkManagerCreateNetworkResponder)> {
        if let NetworkManagerRequest::CreateNetwork { name, config, responder } = self {
            Some((name, config, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_network(self) -> Option<(String, NetworkManagerGetNetworkResponder)> {
        if let NetworkManagerRequest::GetNetwork { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            NetworkManagerRequest::ListNetworks { .. } => "list_networks",
            NetworkManagerRequest::CreateNetwork { .. } => "create_network",
            NetworkManagerRequest::GetNetwork { .. } => "get_network",
        }
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl NetworkManagerControlHandle {}

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

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

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

    fn send_raw(&self, mut nets: &[String]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NetworkManagerListNetworksResponse>(
            (nets,),
            self.tx_id,
            0x2488653e0974cc62,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

    fn control_handle(&self) -> &NetworkManagerControlHandle {
        &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 NetworkManagerCreateNetworkResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut status: i32,
        mut net: Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status, net);
        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 status: i32,
        mut net: Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(status, net);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut status: i32,
        mut net: Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NetworkManagerCreateNetworkResponse>(
            (status, net),
            self.tx_id,
            0x6052eb5ac709af,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut net: Option<fidl::endpoints::ClientEnd<NetworkMarker>>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<NetworkManagerGetNetworkResponse>(
            (net,),
            self.tx_id,
            0x59930bf23acc7d9a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for SetupHandleMarker {
    type Proxy = SetupHandleProxy;
    type RequestStream = SetupHandleRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SetupHandleSynchronousProxy;

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

pub trait SetupHandleProxyInterface: Send + Sync {}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SetupHandleSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SetupHandleSynchronousProxy {
    type Proxy = SetupHandleProxy;
    type Protocol = SetupHandleMarker;

    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 SetupHandleSynchronousProxy {
    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<SetupHandleEvent, fidl::Error> {
        SetupHandleEvent::decode(self.client.wait_for_event::<SetupHandleMarker>(deadline)?)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for SetupHandleProxy {
    type Protocol = SetupHandleMarker;

    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 SetupHandleProxy {
    /// Create a new Proxy for fuchsia.netemul.network/SetupHandle.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <SetupHandleMarker 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) -> SetupHandleEventStream {
        SetupHandleEventStream { event_receiver: self.client.take_event_receiver() }
    }
}

impl SetupHandleProxyInterface for SetupHandleProxy {}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.netemul.network/SetupHandle.
pub struct SetupHandleRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for SetupHandleRequestStream {
    type Protocol = SetupHandleMarker;
    type ControlHandle = SetupHandleControlHandle;

    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 {
        SetupHandleControlHandle { 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 SetupHandleRequestStream {
    type Item = Result<SetupHandleRequest, 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 SetupHandleRequestStream 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 {
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <SetupHandleMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Handle returned when using NetworkContext.Setup for quick network configuration.
/// Networks and endpoints created by Setup are tied to the lifecycle of the SetupHandle's channel.
#[derive(Debug)]
pub enum SetupHandleRequest {}

impl SetupHandleRequest {
    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {}
    }
}

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl SetupHandleControlHandle {}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for DeviceProxyServeControllerRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

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

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

    impl fidl::encoding::ResourceTypeMarker for DeviceProxyServeDeviceRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

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

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

    impl fidl::encoding::ResourceTypeMarker for EndpointGetPortRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for EndpointGetPortRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                port: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_hardware_network::PortMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for EndpointGetProxyRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

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

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

    impl fidl::encoding::ResourceTypeMarker for EndpointManagerCreateEndpointResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            EndpointManagerCreateEndpointResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut EndpointManagerCreateEndpointResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EndpointManagerCreateEndpointResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                EndpointManagerCreateEndpointResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
                    <fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<EndpointMarker>>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.endpoint
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<i32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<EndpointMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            EndpointManagerCreateEndpointResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EndpointManagerCreateEndpointResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for EndpointManagerCreateEndpointResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                status: fidl::new_empty!(i32, fidl::encoding::DefaultFuchsiaResourceDialect),
                endpoint: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<EndpointMarker>>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for EndpointManagerGetEndpointResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for EndpointManagerGetEndpointResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                endpoint: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<EndpointMarker>>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for NetworkContextCloneRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

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

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

    impl fidl::encoding::ResourceTypeMarker for NetworkContextGetEndpointManagerRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

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

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

    impl fidl::encoding::ResourceTypeMarker for NetworkContextGetNetworkManagerRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

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

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

    impl fidl::encoding::ResourceTypeMarker for NetworkContextSetupResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            NetworkContextSetupResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut NetworkContextSetupResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NetworkContextSetupResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                NetworkContextSetupResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
                    <fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SetupHandleMarker>>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.setup_handle,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<i32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SetupHandleMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            NetworkContextSetupResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NetworkContextSetupResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NetworkContextSetupResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                status: fidl::new_empty!(i32, fidl::encoding::DefaultFuchsiaResourceDialect),
                setup_handle: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SetupHandleMarker>>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for NetworkCreateFakeEndpointRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

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

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

    impl fidl::encoding::ResourceTypeMarker for NetworkManagerCreateNetworkResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            NetworkManagerCreateNetworkResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut NetworkManagerCreateNetworkResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NetworkManagerCreateNetworkResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                NetworkManagerCreateNetworkResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
                    <fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<NetworkMarker>>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.net
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<i32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<NetworkMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            NetworkManagerCreateNetworkResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NetworkManagerCreateNetworkResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NetworkManagerCreateNetworkResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                status: fidl::new_empty!(i32, fidl::encoding::DefaultFuchsiaResourceDialect),
                net: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<NetworkMarker>>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for NetworkManagerGetNetworkResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NetworkManagerGetNetworkResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                net: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<NetworkMarker>>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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