fidl_fuchsia_vsock/

fidl_fuchsia_vsock.rs

// WARNING: This file is machine generated by fidlgen.

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fidl::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

pub const SIGNAL_STREAM_INCOMING: u32 = USER_SIGNAL_0 as u32;

pub const USER_SIGNAL_0: u32 = 16777216;

#[derive(Clone, Debug, PartialEq)]
pub struct AcceptorAcceptRequest {
    pub addr: fidl_fuchsia_hardware_vsock::Addr,
}

impl fidl::Persistable for AcceptorAcceptRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AcceptorAcceptResponse {
    pub con: Option<Box<ConnectionTransport>>,
}

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

/// Collection of objects that represent an open connection.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ConnectionTransport {
    /// `data` socket that is ultimately given to the underlying vsock driver and
    /// is where all incoming data can be received from.
    pub data: fidl::Socket,
    /// `Connection` interface that is retained by a vsock service that can be
    /// used to manipulate the state of a connection or perform more complex
    /// operations than just sending and receiving on a socket.
    pub con: fidl::endpoints::ServerEnd<ConnectionMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ConnectorBindRequest {
    pub remote_cid: u32,
    pub local_port: u32,
    pub listener: fidl::endpoints::ServerEnd<ListenerMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ConnectorConnectRequest {
    pub remote_cid: u32,
    pub remote_port: u32,
    pub con: ConnectionTransport,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ConnectorListenRequest {
    pub local_port: u32,
    pub acceptor: fidl::endpoints::ClientEnd<AcceptorMarker>,
}

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

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

impl fidl::Persistable for ConnectorConnectResponse {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ListenerAcceptRequest {
    pub con: ConnectionTransport,
}

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

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ListenerListenRequest {
    /// The maximum length to which the queue of pending connections waiting to
    /// be accepted.
    pub backlog: u32,
}

impl fidl::Persistable for ListenerListenRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct ListenerAcceptResponse {
    pub addr: fidl_fuchsia_hardware_vsock::Addr,
}

impl fidl::Persistable for ListenerAcceptResponse {}

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

impl fidl::endpoints::ProtocolMarker for AcceptorMarker {
    type Proxy = AcceptorProxy;
    type RequestStream = AcceptorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AcceptorSynchronousProxy;

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

pub trait AcceptorProxyInterface: Send + Sync {
    type AcceptResponseFut: std::future::Future<Output = Result<Option<Box<ConnectionTransport>>, fidl::Error>>
        + Send;
    fn r#accept(&self, addr: &fidl_fuchsia_hardware_vsock::Addr) -> Self::AcceptResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AcceptorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AcceptorSynchronousProxy {
    type Proxy = AcceptorProxy;
    type Protocol = AcceptorMarker;

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

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

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

    /// The response is either a `ConnectionTransport` to indicate that the connection
    /// is accepted, or none to indicate that it should be rejected.
    pub fn r#accept(
        &self,
        mut addr: &fidl_fuchsia_hardware_vsock::Addr,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Option<Box<ConnectionTransport>>, fidl::Error> {
        let _response = self.client.send_query::<AcceptorAcceptRequest, AcceptorAcceptResponse>(
            (addr,),
            0x21fd057ad9c9f443,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.con)
    }
}

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

impl fidl::endpoints::Proxy for AcceptorProxy {
    type Protocol = AcceptorMarker;

    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 AcceptorProxy {
    /// Create a new Proxy for fuchsia.vsock/Acceptor.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <AcceptorMarker 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) -> AcceptorEventStream {
        AcceptorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// The response is either a `ConnectionTransport` to indicate that the connection
    /// is accepted, or none to indicate that it should be rejected.
    pub fn r#accept(
        &self,
        mut addr: &fidl_fuchsia_hardware_vsock::Addr,
    ) -> fidl::client::QueryResponseFut<
        Option<Box<ConnectionTransport>>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AcceptorProxyInterface::r#accept(self, addr)
    }
}

impl AcceptorProxyInterface for AcceptorProxy {
    type AcceptResponseFut = fidl::client::QueryResponseFut<
        Option<Box<ConnectionTransport>>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#accept(&self, mut addr: &fidl_fuchsia_hardware_vsock::Addr) -> Self::AcceptResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Option<Box<ConnectionTransport>>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                AcceptorAcceptResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x21fd057ad9c9f443,
            >(_buf?)?;
            Ok(_response.con)
        }
        self.client
            .send_query_and_decode::<AcceptorAcceptRequest, Option<Box<ConnectionTransport>>>(
                (addr,),
                0x21fd057ad9c9f443,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.vsock/Acceptor.
pub struct AcceptorRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for AcceptorRequestStream {
    type Protocol = AcceptorMarker;
    type ControlHandle = AcceptorControlHandle;

    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 {
        AcceptorControlHandle { 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 AcceptorRequestStream {
    type Item = Result<AcceptorRequest, 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 AcceptorRequestStream 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 {
                    0x21fd057ad9c9f443 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AcceptorAcceptRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AcceptorAcceptRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AcceptorControlHandle { inner: this.inner.clone() };
                        Ok(AcceptorRequest::Accept {
                            addr: req.addr,

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

/// Interface presented by a listener to accept or reject connections
#[derive(Debug)]
pub enum AcceptorRequest {
    /// The response is either a `ConnectionTransport` to indicate that the connection
    /// is accepted, or none to indicate that it should be rejected.
    Accept { addr: fidl_fuchsia_hardware_vsock::Addr, responder: AcceptorAcceptResponder },
}

impl AcceptorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_accept(
        self,
    ) -> Option<(fidl_fuchsia_hardware_vsock::Addr, AcceptorAcceptResponder)> {
        if let AcceptorRequest::Accept { addr, responder } = self {
            Some((addr, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

    fn send_raw(&self, mut con: Option<ConnectionTransport>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<AcceptorAcceptResponse>(
            (con.as_mut(),),
            self.tx_id,
            0x21fd057ad9c9f443,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for ConnectionMarker {
    type Proxy = ConnectionProxy;
    type RequestStream = ConnectionRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ConnectionSynchronousProxy;

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

pub trait ConnectionProxyInterface: Send + Sync {
    fn r#shutdown(&self) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ConnectionSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ConnectionSynchronousProxy {
    type Proxy = ConnectionProxy;
    type Protocol = ConnectionMarker;

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

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

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

    /// Trigger asynchronous shutdown. The underlying channel will be closed
    /// once shutdown is complete. Shutdown has an implicit barrier as any already
    /// queued sends will complete, but any additional sends will generate errors
    pub fn r#shutdown(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x40da7ca487466971,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::Proxy for ConnectionProxy {
    type Protocol = ConnectionMarker;

    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 ConnectionProxy {
    /// Create a new Proxy for fuchsia.vsock/Connection.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ConnectionMarker 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) -> ConnectionEventStream {
        ConnectionEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Trigger asynchronous shutdown. The underlying channel will be closed
    /// once shutdown is complete. Shutdown has an implicit barrier as any already
    /// queued sends will complete, but any additional sends will generate errors
    pub fn r#shutdown(&self) -> Result<(), fidl::Error> {
        ConnectionProxyInterface::r#shutdown(self)
    }
}

impl ConnectionProxyInterface for ConnectionProxy {
    fn r#shutdown(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x40da7ca487466971,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.vsock/Connection.
pub struct ConnectionRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ConnectionRequestStream {
    type Protocol = ConnectionMarker;
    type ControlHandle = ConnectionControlHandle;

    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 {
        ConnectionControlHandle { 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 ConnectionRequestStream {
    type Item = Result<ConnectionRequest, 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 ConnectionRequestStream 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 {
                    0x40da7ca487466971 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        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 = ConnectionControlHandle { inner: this.inner.clone() };
                        Ok(ConnectionRequest::Shutdown { control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ConnectionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Interface for manipulating the state of an active connection.
#[derive(Debug)]
pub enum ConnectionRequest {
    /// Trigger asynchronous shutdown. The underlying channel will be closed
    /// once shutdown is complete. Shutdown has an implicit barrier as any already
    /// queued sends will complete, but any additional sends will generate errors
    Shutdown { control_handle: ConnectionControlHandle },
}

impl ConnectionRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_shutdown(self) -> Option<(ConnectionControlHandle)> {
        if let ConnectionRequest::Shutdown { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ConnectorMarker {
    type Proxy = ConnectorProxy;
    type RequestStream = ConnectorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ConnectorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.vsock.Connector";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ConnectorMarker {}
pub type ConnectorConnectResult = Result<u32, i32>;
pub type ConnectorListenResult = Result<(), i32>;
pub type ConnectorBindResult = Result<(), i32>;

pub trait ConnectorProxyInterface: Send + Sync {
    type ConnectResponseFut: std::future::Future<Output = Result<ConnectorConnectResult, fidl::Error>>
        + Send;
    fn r#connect(
        &self,
        remote_cid: u32,
        remote_port: u32,
        con: ConnectionTransport,
    ) -> Self::ConnectResponseFut;
    type ListenResponseFut: std::future::Future<Output = Result<ConnectorListenResult, fidl::Error>>
        + Send;
    fn r#listen(
        &self,
        local_port: u32,
        acceptor: fidl::endpoints::ClientEnd<AcceptorMarker>,
    ) -> Self::ListenResponseFut;
    type BindResponseFut: std::future::Future<Output = Result<ConnectorBindResult, fidl::Error>>
        + Send;
    fn r#bind(
        &self,
        remote_cid: u32,
        local_port: u32,
        listener: fidl::endpoints::ServerEnd<ListenerMarker>,
    ) -> Self::BindResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ConnectorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ConnectorSynchronousProxy {
    type Proxy = ConnectorProxy;
    type Protocol = ConnectorMarker;

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

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

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

    /// Attempt to establish a connection to the specified remote cid/port pair.
    /// No local port is specified as an ephemeral one will automatically be allocated.
    pub fn r#connect(
        &self,
        mut remote_cid: u32,
        mut remote_port: u32,
        mut con: ConnectionTransport,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ConnectorConnectResult, fidl::Error> {
        let _response = self.client.send_query::<
            ConnectorConnectRequest,
            fidl::encoding::ResultType<ConnectorConnectResponse, i32>,
        >(
            (remote_cid, remote_port, &mut con,),
            0xdf55c5e6a6a4117,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.local_port))
    }

    /// Registers a listener for a local port. There can only be one listener for
    /// a single port at a time.
    pub fn r#listen(
        &self,
        mut local_port: u32,
        mut acceptor: fidl::endpoints::ClientEnd<AcceptorMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ConnectorListenResult, fidl::Error> {
        let _response = self.client.send_query::<
            ConnectorListenRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (local_port, acceptor,),
            0x17c1371908bacf73,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Registers a listener for a local port. There can only be one listener for
    /// a single port at a time.
    pub fn r#bind(
        &self,
        mut remote_cid: u32,
        mut local_port: u32,
        mut listener: fidl::endpoints::ServerEnd<ListenerMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ConnectorBindResult, fidl::Error> {
        let _response = self.client.send_query::<
            ConnectorBindRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (remote_cid, local_port, listener,),
            0x6e50cd8c895f2e0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

impl fidl::endpoints::Proxy for ConnectorProxy {
    type Protocol = ConnectorMarker;

    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 ConnectorProxy {
    /// Create a new Proxy for fuchsia.vsock/Connector.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ConnectorMarker 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) -> ConnectorEventStream {
        ConnectorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Attempt to establish a connection to the specified remote cid/port pair.
    /// No local port is specified as an ephemeral one will automatically be allocated.
    pub fn r#connect(
        &self,
        mut remote_cid: u32,
        mut remote_port: u32,
        mut con: ConnectionTransport,
    ) -> fidl::client::QueryResponseFut<
        ConnectorConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ConnectorProxyInterface::r#connect(self, remote_cid, remote_port, con)
    }

    /// Registers a listener for a local port. There can only be one listener for
    /// a single port at a time.
    pub fn r#listen(
        &self,
        mut local_port: u32,
        mut acceptor: fidl::endpoints::ClientEnd<AcceptorMarker>,
    ) -> fidl::client::QueryResponseFut<
        ConnectorListenResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ConnectorProxyInterface::r#listen(self, local_port, acceptor)
    }

    /// Registers a listener for a local port. There can only be one listener for
    /// a single port at a time.
    pub fn r#bind(
        &self,
        mut remote_cid: u32,
        mut local_port: u32,
        mut listener: fidl::endpoints::ServerEnd<ListenerMarker>,
    ) -> fidl::client::QueryResponseFut<
        ConnectorBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ConnectorProxyInterface::r#bind(self, remote_cid, local_port, listener)
    }
}

impl ConnectorProxyInterface for ConnectorProxy {
    type ConnectResponseFut = fidl::client::QueryResponseFut<
        ConnectorConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(
        &self,
        mut remote_cid: u32,
        mut remote_port: u32,
        mut con: ConnectionTransport,
    ) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ConnectorConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ConnectorConnectResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xdf55c5e6a6a4117,
            >(_buf?)?;
            Ok(_response.map(|x| x.local_port))
        }
        self.client.send_query_and_decode::<ConnectorConnectRequest, ConnectorConnectResult>(
            (remote_cid, remote_port, &mut con),
            0xdf55c5e6a6a4117,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ListenResponseFut = fidl::client::QueryResponseFut<
        ConnectorListenResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#listen(
        &self,
        mut local_port: u32,
        mut acceptor: fidl::endpoints::ClientEnd<AcceptorMarker>,
    ) -> Self::ListenResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ConnectorListenResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x17c1371908bacf73,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<ConnectorListenRequest, ConnectorListenResult>(
            (local_port, acceptor),
            0x17c1371908bacf73,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type BindResponseFut = fidl::client::QueryResponseFut<
        ConnectorBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#bind(
        &self,
        mut remote_cid: u32,
        mut local_port: u32,
        mut listener: fidl::endpoints::ServerEnd<ListenerMarker>,
    ) -> Self::BindResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ConnectorBindResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6e50cd8c895f2e0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<ConnectorBindRequest, ConnectorBindResult>(
            (remote_cid, local_port, listener),
            0x6e50cd8c895f2e0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.vsock/Connector.
pub struct ConnectorRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ConnectorRequestStream {
    type Protocol = ConnectorMarker;
    type ControlHandle = ConnectorControlHandle;

    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 {
        ConnectorControlHandle { 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 ConnectorRequestStream {
    type Item = Result<ConnectorRequest, 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 ConnectorRequestStream 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 {
                    0xdf55c5e6a6a4117 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ConnectorConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ConnectorConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ConnectorControlHandle { inner: this.inner.clone() };
                        Ok(ConnectorRequest::Connect {
                            remote_cid: req.remote_cid,
                            remote_port: req.remote_port,
                            con: req.con,

                            responder: ConnectorConnectResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x17c1371908bacf73 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ConnectorListenRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ConnectorListenRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ConnectorControlHandle { inner: this.inner.clone() };
                        Ok(ConnectorRequest::Listen {
                            local_port: req.local_port,
                            acceptor: req.acceptor,

                            responder: ConnectorListenResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e50cd8c895f2e0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ConnectorBindRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ConnectorBindRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ConnectorControlHandle { inner: this.inner.clone() };
                        Ok(ConnectorRequest::Bind {
                            remote_cid: req.remote_cid,
                            local_port: req.local_port,
                            listener: req.listener,

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

/// Exposed by a service that can act as a bridge to the underlying vsock driver and
/// provides the ability for listeners to be multiplexed by port and manages dynamic
/// port allocation for outbound connections.
#[derive(Debug)]
pub enum ConnectorRequest {
    /// Attempt to establish a connection to the specified remote cid/port pair.
    /// No local port is specified as an ephemeral one will automatically be allocated.
    Connect {
        remote_cid: u32,
        remote_port: u32,
        con: ConnectionTransport,
        responder: ConnectorConnectResponder,
    },
    /// Registers a listener for a local port. There can only be one listener for
    /// a single port at a time.
    Listen {
        local_port: u32,
        acceptor: fidl::endpoints::ClientEnd<AcceptorMarker>,
        responder: ConnectorListenResponder,
    },
    /// Registers a listener for a local port. There can only be one listener for
    /// a single port at a time.
    Bind {
        remote_cid: u32,
        local_port: u32,
        listener: fidl::endpoints::ServerEnd<ListenerMarker>,
        responder: ConnectorBindResponder,
    },
}

impl ConnectorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(u32, u32, ConnectionTransport, ConnectorConnectResponder)> {
        if let ConnectorRequest::Connect { remote_cid, remote_port, con, responder } = self {
            Some((remote_cid, remote_port, con, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_listen(
        self,
    ) -> Option<(u32, fidl::endpoints::ClientEnd<AcceptorMarker>, ConnectorListenResponder)> {
        if let ConnectorRequest::Listen { local_port, acceptor, responder } = self {
            Some((local_port, acceptor, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind(
        self,
    ) -> Option<(u32, u32, fidl::endpoints::ServerEnd<ListenerMarker>, ConnectorBindResponder)>
    {
        if let ConnectorRequest::Bind { remote_cid, local_port, listener, responder } = self {
            Some((remote_cid, local_port, listener, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<u32, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<ConnectorConnectResponse, i32>>(
            result.map(|local_port| (local_port,)),
            self.tx_id,
            0xdf55c5e6a6a4117,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ListenerMarker {
    type Proxy = ListenerProxy;
    type RequestStream = ListenerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ListenerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Listener";
}
pub type ListenerListenResult = Result<(), i32>;
pub type ListenerAcceptResult = Result<fidl_fuchsia_hardware_vsock::Addr, i32>;

pub trait ListenerProxyInterface: Send + Sync {
    type ListenResponseFut: std::future::Future<Output = Result<ListenerListenResult, fidl::Error>>
        + Send;
    fn r#listen(&self, backlog: u32) -> Self::ListenResponseFut;
    type AcceptResponseFut: std::future::Future<Output = Result<ListenerAcceptResult, fidl::Error>>
        + Send;
    fn r#accept(&self, con: ConnectionTransport) -> Self::AcceptResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ListenerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ListenerSynchronousProxy {
    type Proxy = ListenerProxy;
    type Protocol = ListenerMarker;

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

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

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

    /// Registers a listener for a local port. There can only be one listener for
    /// a single port at a time. The channel will have `SIGNAL_STREAM_INCOMING` asserted
    /// by the server when there is a connection ready to accept.
    pub fn r#listen(
        &self,
        mut backlog: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ListenerListenResult, fidl::Error> {
        let _response = self.client.send_query::<
            ListenerListenRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (backlog,),
            0x53042f6a15d94464,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Accept a pending connection from the queue after `Listen` was invoked and
    /// `SIGNAL_STREAM_INCOMING` was signaled.
    pub fn r#accept(
        &self,
        mut con: ConnectionTransport,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ListenerAcceptResult, fidl::Error> {
        let _response = self.client.send_query::<
            ListenerAcceptRequest,
            fidl::encoding::ResultType<ListenerAcceptResponse, i32>,
        >(
            (&mut con,),
            0x4b71e6389d92d322,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.addr))
    }
}

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

impl fidl::endpoints::Proxy for ListenerProxy {
    type Protocol = ListenerMarker;

    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 ListenerProxy {
    /// Create a new Proxy for fuchsia.vsock/Listener.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ListenerMarker 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) -> ListenerEventStream {
        ListenerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Registers a listener for a local port. There can only be one listener for
    /// a single port at a time. The channel will have `SIGNAL_STREAM_INCOMING` asserted
    /// by the server when there is a connection ready to accept.
    pub fn r#listen(
        &self,
        mut backlog: u32,
    ) -> fidl::client::QueryResponseFut<
        ListenerListenResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ListenerProxyInterface::r#listen(self, backlog)
    }

    /// Accept a pending connection from the queue after `Listen` was invoked and
    /// `SIGNAL_STREAM_INCOMING` was signaled.
    pub fn r#accept(
        &self,
        mut con: ConnectionTransport,
    ) -> fidl::client::QueryResponseFut<
        ListenerAcceptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ListenerProxyInterface::r#accept(self, con)
    }
}

impl ListenerProxyInterface for ListenerProxy {
    type ListenResponseFut = fidl::client::QueryResponseFut<
        ListenerListenResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#listen(&self, mut backlog: u32) -> Self::ListenResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ListenerListenResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x53042f6a15d94464,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<ListenerListenRequest, ListenerListenResult>(
            (backlog,),
            0x53042f6a15d94464,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AcceptResponseFut = fidl::client::QueryResponseFut<
        ListenerAcceptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#accept(&self, mut con: ConnectionTransport) -> Self::AcceptResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ListenerAcceptResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ListenerAcceptResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4b71e6389d92d322,
            >(_buf?)?;
            Ok(_response.map(|x| x.addr))
        }
        self.client.send_query_and_decode::<ListenerAcceptRequest, ListenerAcceptResult>(
            (&mut con,),
            0x4b71e6389d92d322,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.vsock/Listener.
pub struct ListenerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ListenerRequestStream {
    type Protocol = ListenerMarker;
    type ControlHandle = ListenerControlHandle;

    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 {
        ListenerControlHandle { 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 ListenerRequestStream {
    type Item = Result<ListenerRequest, 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 ListenerRequestStream 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 {
                    0x53042f6a15d94464 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ListenerListenRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ListenerListenRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ListenerControlHandle { inner: this.inner.clone() };
                        Ok(ListenerRequest::Listen {
                            backlog: req.backlog,

                            responder: ListenerListenResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4b71e6389d92d322 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ListenerAcceptRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ListenerAcceptRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ListenerControlHandle { inner: this.inner.clone() };
                        Ok(ListenerRequest::Accept {
                            con: req.con,

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

/// Interface presented by a listener to accept connections.
#[derive(Debug)]
pub enum ListenerRequest {
    /// Registers a listener for a local port. There can only be one listener for
    /// a single port at a time. The channel will have `SIGNAL_STREAM_INCOMING` asserted
    /// by the server when there is a connection ready to accept.
    Listen { backlog: u32, responder: ListenerListenResponder },
    /// Accept a pending connection from the queue after `Listen` was invoked and
    /// `SIGNAL_STREAM_INCOMING` was signaled.
    Accept { con: ConnectionTransport, responder: ListenerAcceptResponder },
}

impl ListenerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_listen(self) -> Option<(u32, ListenerListenResponder)> {
        if let ListenerRequest::Listen { backlog, responder } = self {
            Some((backlog, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_accept(self) -> Option<(ConnectionTransport, ListenerAcceptResponder)> {
        if let ListenerRequest::Accept { con, responder } = self {
            Some((con, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ListenerRequest::Listen { .. } => "listen",
            ListenerRequest::Accept { .. } => "accept",
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_hardware_vsock::Addr, i32>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<ListenerAcceptResponse, i32>>(
            result.map(|addr| (addr,)),
            self.tx_id,
            0x4b71e6389d92d322,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

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

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

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

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

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

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AcceptorAcceptRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { addr: fidl::new_empty!(fidl_fuchsia_hardware_vsock::Addr, D) }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            AcceptorAcceptResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut AcceptorAcceptResponse
    {
        #[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::<AcceptorAcceptResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AcceptorAcceptResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Boxed<ConnectionTransport> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.con),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Boxed<ConnectionTransport>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            AcceptorAcceptResponse,
            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::<AcceptorAcceptResponse>(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 AcceptorAcceptResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                con: fidl::new_empty!(
                    fidl::encoding::Boxed<ConnectionTransport>,
                    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::Boxed<ConnectionTransport>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.con,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ConnectionTransport {
        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 ConnectionTransport {
        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<ConnectionTransport, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut ConnectionTransport
    {
        #[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::<ConnectionTransport>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ConnectionTransport, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.data),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ConnectionMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.con),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ConnectionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<ConnectionTransport, 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::<ConnectionTransport>(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 ConnectionTransport
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                data: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                con: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ConnectionMarker>>,
                    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::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.data, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ConnectionMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.con,
                decoder,
                offset + 4,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<ConnectorBindRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut ConnectorBindRequest
    {
        #[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::<ConnectorBindRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ConnectorBindRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.remote_cid),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.local_port),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ListenerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.listener),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ListenerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<ConnectorBindRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2)
    {
        #[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::<ConnectorBindRequest>(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)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ConnectorBindRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                remote_cid: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                local_port: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                listener: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ListenerMarker>>,
                    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!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.remote_cid,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.local_port,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ListenerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.listener,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            ConnectorConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ConnectorConnectRequest
    {
        #[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::<ConnectorConnectRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ConnectorConnectRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.remote_cid),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.remote_port),
                    <ConnectionTransport as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.con,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T2: fidl::encoding::Encode<
                ConnectionTransport,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ConnectorConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[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::<ConnectorConnectRequest>(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)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ConnectorConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                remote_cid: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                remote_port: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                con: fidl::new_empty!(
                    ConnectionTransport,
                    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!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.remote_cid,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.remote_port,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                ConnectionTransport,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.con,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

    impl fidl::encoding::ResourceTypeMarker for ListenerAcceptRequest {
        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 ListenerAcceptRequest {
        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<ListenerAcceptRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut ListenerAcceptRequest
    {
        #[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::<ListenerAcceptRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ListenerAcceptRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<ConnectionTransport as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.con,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                ConnectionTransport,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<ListenerAcceptRequest, 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::<ListenerAcceptRequest>(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 ListenerAcceptRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                con: fidl::new_empty!(
                    ConnectionTransport,
                    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!(
                ConnectionTransport,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.con,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ListenerAcceptResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { addr: fidl::new_empty!(fidl_fuchsia_hardware_vsock::Addr, D) }
        }

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