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 _};
pub use fidl_fuchsia_vsock__common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[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(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ListenerAcceptRequest {
    pub con: ConnectionTransport,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ProviderStreamSocketRequest {
    pub server: fidl::endpoints::ServerEnd<StreamSocketMarker>,
    pub data: fidl::Socket,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct StreamSocketAcceptRequest {
    pub want_addr: bool,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct StreamSocketConnectRequest {
    pub remote_address: VsockAddress,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct StreamSocketAcceptResponse {
    pub socket: Option<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
    pub data: Option<fidl::Socket>,
    pub addr: Option<VsockAddress>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[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)
    }
}

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

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

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

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

#[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(),
        )
    }
}

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

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

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

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

#[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;
    type GetCidResponseFut: std::future::Future<Output = Result<u32, fidl::Error>> + Send;
    fn r#get_cid(&self) -> Self::GetCidResponseFut;
}
#[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))
    }

    /// Query the current context id of the system. The local CID is should not
    /// necessary in interactions with the same device; instead you may pass
    /// `VMADDR_CID_LOCAL`, which will alias to local CID this returns. The cid returned
    /// by this method is useful for debugging or if you have some other communication
    /// channel to a different host and you would like to send them your CID to then
    /// establish a vsock connection on.
    pub fn r#get_cid(&self, ___deadline: zx::MonotonicInstant) -> Result<u32, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, ConnectorGetCidResponse>(
                (),
                0x60b3cfa0b40bdd7c,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.local_cid)
    }
}

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

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

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

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

#[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)
    }

    /// Query the current context id of the system. The local CID is should not
    /// necessary in interactions with the same device; instead you may pass
    /// `VMADDR_CID_LOCAL`, which will alias to local CID this returns. The cid returned
    /// by this method is useful for debugging or if you have some other communication
    /// channel to a different host and you would like to send them your CID to then
    /// establish a vsock connection on.
    pub fn r#get_cid(
        &self,
    ) -> fidl::client::QueryResponseFut<u32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        ConnectorProxyInterface::r#get_cid(self)
    }
}

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,
        )
    }

    type GetCidResponseFut =
        fidl::client::QueryResponseFut<u32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_cid(&self) -> Self::GetCidResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ConnectorGetCidResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x60b3cfa0b40bdd7c,
            >(_buf?)?;
            Ok(_response.local_cid)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u32>(
            (),
            0x60b3cfa0b40bdd7c,
            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,
                            },
                        })
                    }
                    0x60b3cfa0b40bdd7c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ConnectorControlHandle { inner: this.inner.clone() };
                        Ok(ConnectorRequest::GetCid {
                            responder: ConnectorGetCidResponder {
                                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,
    },
    /// Query the current context id of the system. The local CID is should not
    /// necessary in interactions with the same device; instead you may pass
    /// `VMADDR_CID_LOCAL`, which will alias to local CID this returns. The cid returned
    /// by this method is useful for debugging or if you have some other communication
    /// channel to a different host and you would like to send them your CID to then
    /// establish a vsock connection on.
    GetCid { responder: ConnectorGetCidResponder },
}

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
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_cid(self) -> Option<(ConnectorGetCidResponder)> {
        if let ConnectorRequest::GetCid { responder } = self { Some((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",
            ConnectorRequest::GetCid { .. } => "get_cid",
        }
    }
}

#[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(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ConnectorGetCidResponder {
    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 ConnectorGetCidResponder {
    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 ConnectorGetCidResponder {
    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 ConnectorGetCidResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut local_cid: u32) -> Result<(), fidl::Error> {
        let _result = self.send_raw(local_cid);
        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 local_cid: u32) -> Result<(), fidl::Error> {
        let _result = self.send_raw(local_cid);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut local_cid: u32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ConnectorGetCidResponse>(
            (local_cid,),
            self.tx_id,
            0x60b3cfa0b40bdd7c,
            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))
    }
}

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

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

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

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

#[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(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for ProviderMarker {
    type Proxy = ProviderProxy;
    type RequestStream = ProviderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ProviderSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.vsock.Provider";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ProviderMarker {}
pub type ProviderStreamSocketResult = Result<(), i32>;

pub trait ProviderProxyInterface: Send + Sync {
    type StreamSocketResponseFut: std::future::Future<Output = Result<ProviderStreamSocketResult, fidl::Error>>
        + Send;
    fn r#stream_socket(
        &self,
        server: fidl::endpoints::ServerEnd<StreamSocketMarker>,
        data: fidl::Socket,
    ) -> Self::StreamSocketResponseFut;
    type GetCidResponseFut: std::future::Future<Output = Result<u32, fidl::Error>> + Send;
    fn r#get_cid(&self) -> Self::GetCidResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ProviderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ProviderSynchronousProxy {
    type Proxy = ProviderProxy;
    type Protocol = ProviderMarker;

    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 ProviderSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ProviderMarker 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<ProviderEvent, fidl::Error> {
        ProviderEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Create a new virtio socket in stream mode.
    pub fn r#stream_socket(
        &self,
        mut server: fidl::endpoints::ServerEnd<StreamSocketMarker>,
        mut data: fidl::Socket,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProviderStreamSocketResult, fidl::Error> {
        let _response = self.client.send_query::<
            ProviderStreamSocketRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (server, data,),
            0x638e6822e8c0c333,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ProviderMarker>("stream_socket")?;
        Ok(_response.map(|x| x))
    }

    /// Query the current context id of the system. The local CID is should not
    /// necessary in interactions with the same device; instead you may pass
    /// `VMADDR_CID_LOCAL`, which will alias to local CID this returns. The cid returned
    /// by this method is useful for debugging or if you have some other communication
    /// channel to a different host and you would like to send them your CID to then
    /// establish a vsock connection on.
    pub fn r#get_cid(&self, ___deadline: zx::MonotonicInstant) -> Result<u32, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, ProviderGetCidResponse>(
                (),
                0x7152b198ab4348df,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.local_cid)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ProviderProxy {
    type Protocol = ProviderMarker;

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

    /// Create a new virtio socket in stream mode.
    pub fn r#stream_socket(
        &self,
        mut server: fidl::endpoints::ServerEnd<StreamSocketMarker>,
        mut data: fidl::Socket,
    ) -> fidl::client::QueryResponseFut<
        ProviderStreamSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProviderProxyInterface::r#stream_socket(self, server, data)
    }

    /// Query the current context id of the system. The local CID is should not
    /// necessary in interactions with the same device; instead you may pass
    /// `VMADDR_CID_LOCAL`, which will alias to local CID this returns. The cid returned
    /// by this method is useful for debugging or if you have some other communication
    /// channel to a different host and you would like to send them your CID to then
    /// establish a vsock connection on.
    pub fn r#get_cid(
        &self,
    ) -> fidl::client::QueryResponseFut<u32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        ProviderProxyInterface::r#get_cid(self)
    }
}

impl ProviderProxyInterface for ProviderProxy {
    type StreamSocketResponseFut = fidl::client::QueryResponseFut<
        ProviderStreamSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#stream_socket(
        &self,
        mut server: fidl::endpoints::ServerEnd<StreamSocketMarker>,
        mut data: fidl::Socket,
    ) -> Self::StreamSocketResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProviderStreamSocketResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x638e6822e8c0c333,
            >(_buf?)?
            .into_result::<ProviderMarker>("stream_socket")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<ProviderStreamSocketRequest, ProviderStreamSocketResult>(
                (server, data),
                0x638e6822e8c0c333,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ProviderRequestStream {
    type Protocol = ProviderMarker;
    type ControlHandle = ProviderControlHandle;

    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 {
        ProviderControlHandle { 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 ProviderRequestStream {
    type Item = Result<ProviderRequest, 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 ProviderRequestStream 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 {
                    0x638e6822e8c0c333 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProviderStreamSocketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderStreamSocketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
                        Ok(ProviderRequest::StreamSocket {
                            server: req.server,
                            data: req.data,

                            responder: ProviderStreamSocketResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7152b198ab4348df => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
                        Ok(ProviderRequest::GetCid {
                            responder: ProviderGetCidResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(ProviderRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ProviderControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::OneWay,
                        })
                    }
                    _ if header
                        .dynamic_flags()
                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        this.inner.send_framework_err(
                            fidl::encoding::FrameworkErr::UnknownMethod,
                            header.tx_id,
                            header.ordinal,
                            header.dynamic_flags(),
                            (bytes, handles),
                        )?;
                        Ok(ProviderRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ProviderControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum ProviderRequest {
    /// Create a new virtio socket in stream mode.
    StreamSocket {
        server: fidl::endpoints::ServerEnd<StreamSocketMarker>,
        data: fidl::Socket,
        responder: ProviderStreamSocketResponder,
    },
    /// Query the current context id of the system. The local CID is should not
    /// necessary in interactions with the same device; instead you may pass
    /// `VMADDR_CID_LOCAL`, which will alias to local CID this returns. The cid returned
    /// by this method is useful for debugging or if you have some other communication
    /// channel to a different host and you would like to send them your CID to then
    /// establish a vsock connection on.
    GetCid { responder: ProviderGetCidResponder },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: ProviderControlHandle,
        method_type: fidl::MethodType,
    },
}

impl ProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_stream_socket(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<StreamSocketMarker>,
        fidl::Socket,
        ProviderStreamSocketResponder,
    )> {
        if let ProviderRequest::StreamSocket { server, data, responder } = self {
            Some((server, data, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_cid(self) -> Option<(ProviderGetCidResponder)> {
        if let ProviderRequest::GetCid { responder } = self { Some((responder)) } else { None }
    }

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut local_cid: u32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ProviderGetCidResponse>(
            (local_cid,),
            self.tx_id,
            0x7152b198ab4348df,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for StreamSocketMarker {
    type Proxy = StreamSocketProxy;
    type RequestStream = StreamSocketRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = StreamSocketSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) StreamSocket";
}
pub type StreamSocketBindResult = Result<(), Error>;
pub type StreamSocketConnectResult = Result<(), Error>;
pub type StreamSocketListenResult = Result<(), Error>;
pub type StreamSocketAcceptResult = Result<StreamSocketAcceptResponse, Error>;
pub type StreamSocketGetSockNameResult = Result<VsockAddress, Error>;
pub type StreamSocketGetPeerNameResult = Result<VsockAddress, Error>;
pub type StreamSocketGetErrorResult = Result<(), Error>;

pub trait StreamSocketProxyInterface: Send + Sync {
    type CloseResponseFut: std::future::Future<
            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
        > + Send;
    fn r#close(&self) -> Self::CloseResponseFut;
    type BindResponseFut: std::future::Future<Output = Result<StreamSocketBindResult, fidl::Error>>
        + Send;
    fn r#bind(&self, addr: &VsockAddress) -> Self::BindResponseFut;
    type ConnectResponseFut: std::future::Future<Output = Result<StreamSocketConnectResult, fidl::Error>>
        + Send;
    fn r#connect(&self, remote_address: &VsockAddress) -> Self::ConnectResponseFut;
    type ListenResponseFut: std::future::Future<Output = Result<StreamSocketListenResult, fidl::Error>>
        + Send;
    fn r#listen(&self, backlog: i32) -> Self::ListenResponseFut;
    type AcceptResponseFut: std::future::Future<Output = Result<StreamSocketAcceptResult, fidl::Error>>
        + Send;
    fn r#accept(&self, want_addr: bool) -> Self::AcceptResponseFut;
    type GetSockNameResponseFut: std::future::Future<Output = Result<StreamSocketGetSockNameResult, fidl::Error>>
        + Send;
    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
    type GetPeerNameResponseFut: std::future::Future<Output = Result<StreamSocketGetPeerNameResult, fidl::Error>>
        + Send;
    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
    type GetErrorResponseFut: std::future::Future<Output = Result<StreamSocketGetErrorResult, fidl::Error>>
        + Send;
    fn r#get_error(&self) -> Self::GetErrorResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct StreamSocketSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for StreamSocketSynchronousProxy {
    type Proxy = StreamSocketProxy;
    type Protocol = StreamSocketMarker;

    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 StreamSocketSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <StreamSocketMarker 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<StreamSocketEvent, fidl::Error> {
        StreamSocketEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Bind this socket to a specific address.
    pub fn r#bind(
        &self,
        mut addr: &VsockAddress,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketBindResult, fidl::Error> {
        let _response = self.client.send_query::<
            StreamSocketBindRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (addr,),
            0x72dc3c63cf24329,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<StreamSocketMarker>("bind")?;
        Ok(_response.map(|x| x))
    }

    /// Initiate a connection to |remote_address|.
    /// When the connection attempt completes the signal SIGNAL_STREAM_CONNECTED
    /// will be asserted on the data plane zx.Handle:SOCKET.
    pub fn r#connect(
        &self,
        mut remote_address: &VsockAddress,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketConnectResult, fidl::Error> {
        let _response = self.client.send_query::<
            StreamSocketConnectRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (remote_address,),
            0x50822e8e18b27e75,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<StreamSocketMarker>("connect")?;
        Ok(_response.map(|x| x))
    }

    /// Places this socket into listening mode with a specified backlog.
    /// When a new connection is available the signal SIGNAL_STREAM_INCOMING
    /// will be asserted on the data plane zx.Handle:SOCKET.
    pub fn r#listen(
        &self,
        mut backlog: i32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketListenResult, fidl::Error> {
        let _response = self.client.send_query::<
            StreamSocketListenRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (backlog,),
            0x4a5b1f2bc958287f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<StreamSocketMarker>("listen")?;
        Ok(_response.map(|x| x))
    }

    /// Accepts a connection from this socket's listen backlog and binds it to
    /// |socket| with data plane |data|.
    /// If |want_addr| is true, returns the address of the accepted socket.
    /// When this call returns, if SIGNAL_STREAM_INCOMING is asserted another
    /// incoming connection is available.
    pub fn r#accept(
        &self,
        mut want_addr: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketAcceptResult, fidl::Error> {
        let _response = self.client.send_query::<
            StreamSocketAcceptRequest,
            fidl::encoding::FlexibleResultType<StreamSocketAcceptResponse, Error>,
        >(
            (want_addr,),
            0x10d5fe50cbe19aea,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<StreamSocketMarker>("accept")?;
        Ok(_response.map(|x| x))
    }

    /// Retrieves the local socket address.
    pub fn r#get_sock_name(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetSockNameResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<StreamSocketGetSockNameResponse, Error>,
        >(
            (),
            0x2011f4a50477ec73,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<StreamSocketMarker>("get_sock_name")?;
        Ok(_response.map(|x| x.addr))
    }

    /// Retrieves the remote socket address.
    pub fn r#get_peer_name(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetPeerNameResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<StreamSocketGetPeerNameResponse, Error>,
        >(
            (),
            0x6165feb6a459fb8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<StreamSocketMarker>("get_peer_name")?;
        Ok(_response.map(|x| x.addr))
    }

    /// Get `SOL_SOCKET` -> `SO_ERROR`
    pub fn r#get_error(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetErrorResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
        >(
            (),
            0x18b3da9cea924b38,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<StreamSocketMarker>("get_error")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for StreamSocketProxy {
    type Protocol = StreamSocketMarker;

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

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#close(self)
    }

    /// Bind this socket to a specific address.
    pub fn r#bind(
        &self,
        mut addr: &VsockAddress,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#bind(self, addr)
    }

    /// Initiate a connection to |remote_address|.
    /// When the connection attempt completes the signal SIGNAL_STREAM_CONNECTED
    /// will be asserted on the data plane zx.Handle:SOCKET.
    pub fn r#connect(
        &self,
        mut remote_address: &VsockAddress,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#connect(self, remote_address)
    }

    /// Places this socket into listening mode with a specified backlog.
    /// When a new connection is available the signal SIGNAL_STREAM_INCOMING
    /// will be asserted on the data plane zx.Handle:SOCKET.
    pub fn r#listen(
        &self,
        mut backlog: i32,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketListenResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#listen(self, backlog)
    }

    /// Accepts a connection from this socket's listen backlog and binds it to
    /// |socket| with data plane |data|.
    /// If |want_addr| is true, returns the address of the accepted socket.
    /// When this call returns, if SIGNAL_STREAM_INCOMING is asserted another
    /// incoming connection is available.
    pub fn r#accept(
        &self,
        mut want_addr: bool,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketAcceptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#accept(self, want_addr)
    }

    /// Retrieves the local socket address.
    pub fn r#get_sock_name(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetSockNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_sock_name(self)
    }

    /// Retrieves the remote socket address.
    pub fn r#get_peer_name(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetPeerNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_peer_name(self)
    }

    /// Get `SOL_SOCKET` -> `SO_ERROR`
    pub fn r#get_error(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetErrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_error(self)
    }
}

impl StreamSocketProxyInterface for StreamSocketProxy {
    type CloseResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#close(&self) -> Self::CloseResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5ac5d459ad7f657e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::CloseableCloseResult,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type BindResponseFut = fidl::client::QueryResponseFut<
        StreamSocketBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#bind(&self, mut addr: &VsockAddress) -> Self::BindResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketBindResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x72dc3c63cf24329,
            >(_buf?)?
            .into_result::<StreamSocketMarker>("bind")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<StreamSocketBindRequest, StreamSocketBindResult>(
            (addr,),
            0x72dc3c63cf24329,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ConnectResponseFut = fidl::client::QueryResponseFut<
        StreamSocketConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(&self, mut remote_address: &VsockAddress) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x50822e8e18b27e75,
            >(_buf?)?
            .into_result::<StreamSocketMarker>("connect")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<StreamSocketConnectRequest, StreamSocketConnectResult>(
            (remote_address,),
            0x50822e8e18b27e75,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ListenResponseFut = fidl::client::QueryResponseFut<
        StreamSocketListenResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#listen(&self, mut backlog: i32) -> Self::ListenResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketListenResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4a5b1f2bc958287f,
            >(_buf?)?
            .into_result::<StreamSocketMarker>("listen")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<StreamSocketListenRequest, StreamSocketListenResult>(
            (backlog,),
            0x4a5b1f2bc958287f,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type AcceptResponseFut = fidl::client::QueryResponseFut<
        StreamSocketAcceptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#accept(&self, mut want_addr: bool) -> Self::AcceptResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketAcceptResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<StreamSocketAcceptResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x10d5fe50cbe19aea,
            >(_buf?)?
            .into_result::<StreamSocketMarker>("accept")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<StreamSocketAcceptRequest, StreamSocketAcceptResult>(
            (want_addr,),
            0x10d5fe50cbe19aea,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetSockNameResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetSockNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetSockNameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<StreamSocketGetSockNameResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2011f4a50477ec73,
            >(_buf?)?
            .into_result::<StreamSocketMarker>("get_sock_name")?;
            Ok(_response.map(|x| x.addr))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetSockNameResult>(
                (),
                0x2011f4a50477ec73,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetPeerNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetPeerNameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<StreamSocketGetPeerNameResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6165feb6a459fb8,
            >(_buf?)?
            .into_result::<StreamSocketMarker>("get_peer_name")?;
            Ok(_response.map(|x| x.addr))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetPeerNameResult>(
                (),
                0x6165feb6a459fb8,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type GetErrorResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetErrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_error(&self) -> Self::GetErrorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetErrorResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x18b3da9cea924b38,
            >(_buf?)?
            .into_result::<StreamSocketMarker>("get_error")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetErrorResult>(
                (),
                0x18b3da9cea924b38,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for StreamSocketRequestStream {
    type Protocol = StreamSocketMarker;
    type ControlHandle = StreamSocketControlHandle;

    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 {
        StreamSocketControlHandle { 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 StreamSocketRequestStream {
    type Item = Result<StreamSocketRequest, 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 StreamSocketRequestStream 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 {
                    0x5ac5d459ad7f657e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::Close {
                            responder: StreamSocketCloseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x72dc3c63cf24329 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketBindRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::Bind {
                            addr: req.addr,

                            responder: StreamSocketBindResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x50822e8e18b27e75 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::Connect {
                            remote_address: req.remote_address,

                            responder: StreamSocketConnectResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4a5b1f2bc958287f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketListenRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketListenRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::Listen {
                            backlog: req.backlog,

                            responder: StreamSocketListenResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x10d5fe50cbe19aea => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketAcceptRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketAcceptRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::Accept {
                            want_addr: req.want_addr,

                            responder: StreamSocketAcceptResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2011f4a50477ec73 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetSockName {
                            responder: StreamSocketGetSockNameResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6165feb6a459fb8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetPeerName {
                            responder: StreamSocketGetPeerNameResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x18b3da9cea924b38 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetError {
                            responder: StreamSocketGetErrorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(StreamSocketRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: StreamSocketControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::OneWay,
                        })
                    }
                    _ if header
                        .dynamic_flags()
                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        this.inner.send_framework_err(
                            fidl::encoding::FrameworkErr::UnknownMethod,
                            header.tx_id,
                            header.ordinal,
                            header.dynamic_flags(),
                            (bytes, handles),
                        )?;
                        Ok(StreamSocketRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: StreamSocketControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <StreamSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// StreamSocket represents the control plane for a single virtio-socket stream
/// socket.
#[derive(Debug)]
pub enum StreamSocketRequest {
    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    Close { responder: StreamSocketCloseResponder },
    /// Bind this socket to a specific address.
    Bind { addr: VsockAddress, responder: StreamSocketBindResponder },
    /// Initiate a connection to |remote_address|.
    /// When the connection attempt completes the signal SIGNAL_STREAM_CONNECTED
    /// will be asserted on the data plane zx.Handle:SOCKET.
    Connect { remote_address: VsockAddress, responder: StreamSocketConnectResponder },
    /// Places this socket into listening mode with a specified backlog.
    /// When a new connection is available the signal SIGNAL_STREAM_INCOMING
    /// will be asserted on the data plane zx.Handle:SOCKET.
    Listen { backlog: i32, responder: StreamSocketListenResponder },
    /// Accepts a connection from this socket's listen backlog and binds it to
    /// |socket| with data plane |data|.
    /// If |want_addr| is true, returns the address of the accepted socket.
    /// When this call returns, if SIGNAL_STREAM_INCOMING is asserted another
    /// incoming connection is available.
    Accept { want_addr: bool, responder: StreamSocketAcceptResponder },
    /// Retrieves the local socket address.
    GetSockName { responder: StreamSocketGetSockNameResponder },
    /// Retrieves the remote socket address.
    GetPeerName { responder: StreamSocketGetPeerNameResponder },
    /// Get `SOL_SOCKET` -> `SO_ERROR`
    GetError { responder: StreamSocketGetErrorResponder },
    /// An interaction was received which does not match any known method.
    #[non_exhaustive]
    _UnknownMethod {
        /// Ordinal of the method that was called.
        ordinal: u64,
        control_handle: StreamSocketControlHandle,
        method_type: fidl::MethodType,
    },
}

impl StreamSocketRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(StreamSocketCloseResponder)> {
        if let StreamSocketRequest::Close { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind(self) -> Option<(VsockAddress, StreamSocketBindResponder)> {
        if let StreamSocketRequest::Bind { addr, responder } = self {
            Some((addr, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(self) -> Option<(VsockAddress, StreamSocketConnectResponder)> {
        if let StreamSocketRequest::Connect { remote_address, responder } = self {
            Some((remote_address, responder))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_accept(self) -> Option<(bool, StreamSocketAcceptResponder)> {
        if let StreamSocketRequest::Accept { want_addr, responder } = self {
            Some((want_addr, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_sock_name(self) -> Option<(StreamSocketGetSockNameResponder)> {
        if let StreamSocketRequest::GetSockName { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_peer_name(self) -> Option<(StreamSocketGetPeerNameResponder)> {
        if let StreamSocketRequest::GetPeerName { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_error(self) -> Option<(StreamSocketGetErrorResponder)> {
        if let StreamSocketRequest::GetError { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            StreamSocketRequest::Close { .. } => "close",
            StreamSocketRequest::Bind { .. } => "bind",
            StreamSocketRequest::Connect { .. } => "connect",
            StreamSocketRequest::Listen { .. } => "listen",
            StreamSocketRequest::Accept { .. } => "accept",
            StreamSocketRequest::GetSockName { .. } => "get_sock_name",
            StreamSocketRequest::GetPeerName { .. } => "get_peer_name",
            StreamSocketRequest::GetError { .. } => "get_error",
            StreamSocketRequest::_UnknownMethod {
                method_type: fidl::MethodType::OneWay, ..
            } => "unknown one-way method",
            StreamSocketRequest::_UnknownMethod {
                method_type: fidl::MethodType::TwoWay, ..
            } => "unknown two-way method",
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<StreamSocketAcceptResponse, Error>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            StreamSocketAcceptResponse,
            Error,
        >>(
            fidl::encoding::FlexibleResult::new(result.as_mut().map_err(|e| *e)),
            self.tx_id,
            0x10d5fe50cbe19aea,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<&VsockAddress, Error>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            StreamSocketGetSockNameResponse,
            Error,
        >>(
            fidl::encoding::FlexibleResult::new(result.map(|addr| (addr,))),
            self.tx_id,
            0x2011f4a50477ec73,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<&VsockAddress, Error>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            StreamSocketGetPeerNameResponse,
            Error,
        >>(
            fidl::encoding::FlexibleResult::new(result.map(|addr| (addr,))),
            self.tx_id,
            0x6165feb6a459fb8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

mod internal {
    use super::*;

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

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

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

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

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

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

    impl fidl::encoding::ResourceTypeMarker for StreamSocketConnectRequest {
        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 StreamSocketConnectRequest {
        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
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

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

    unsafe impl
        fidl::encoding::Encode<
            StreamSocketConnectRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut StreamSocketConnectRequest
    {
        #[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::<StreamSocketConnectRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut StreamSocketConnectRequest)
                    .write_unaligned((self as *const StreamSocketConnectRequest).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<
        T0: fidl::encoding::Encode<VsockAddress, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<
            StreamSocketConnectRequest,
            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::<StreamSocketConnectRequest>(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 StreamSocketConnectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                remote_address: fidl::new_empty!(
                    VsockAddress,
                    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);
            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, 8);
            }
            Ok(())
        }
    }

    impl StreamSocketAcceptResponse {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.addr {
                return 3;
            }
            if let Some(_) = self.data {
                return 2;
            }
            if let Some(_) = self.socket {
                return 1;
            }
            0
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            StreamSocketAcceptResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut StreamSocketAcceptResponse
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StreamSocketAcceptResponse>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.socket.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::HandleType<
                    fidl::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.data.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::Socket,
                        { fidl::ObjectType::SOCKET.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                VsockAddress,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.addr.as_ref().map(<VsockAddress as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for StreamSocketAcceptResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<StreamSocketMarker>,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.socket.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::HandleType<
                    fidl::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.data.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <VsockAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.addr.get_or_insert_with(|| {
                    fidl::new_empty!(VsockAddress, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    VsockAddress,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }
}