fidl_fuchsia_fdomain/

fidl_fuchsia_fdomain.rs

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

// fidl_experiment = allow_arbitrary_error_types
// fidl_experiment = no_resource_attribute

#![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_fdomain__common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

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

impl fidl::endpoints::ProtocolMarker for ChannelMarker {
    type Proxy = ChannelProxy;
    type RequestStream = ChannelRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ChannelSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Channel";
}
pub type ChannelCreateChannelResult = Result<(), Error>;
pub type ChannelReadChannelResult = Result<(Vec<u8>, Vec<HandleInfo>), Error>;
pub type ChannelWriteChannelResult = Result<(), WriteChannelError>;
pub type ChannelReadChannelStreamingStartResult = Result<(), Error>;
pub type ChannelReadChannelStreamingStopResult = Result<(), Error>;

pub trait ChannelProxyInterface: Send + Sync {
    type CreateChannelResponseFut: std::future::Future<Output = Result<ChannelCreateChannelResult, fidl::Error>>
        + Send;
    fn r#create_channel(&self, handles: &[NewHandleId; 2]) -> Self::CreateChannelResponseFut;
    type ReadChannelResponseFut: std::future::Future<Output = Result<ChannelReadChannelResult, fidl::Error>>
        + Send;
    fn r#read_channel(&self, handle: &HandleId) -> Self::ReadChannelResponseFut;
    type WriteChannelResponseFut: std::future::Future<Output = Result<ChannelWriteChannelResult, fidl::Error>>
        + Send;
    fn r#write_channel(
        &self,
        handle: &HandleId,
        data: &[u8],
        handles: &Handles,
    ) -> Self::WriteChannelResponseFut;
    type ReadChannelStreamingStartResponseFut: std::future::Future<Output = Result<ChannelReadChannelStreamingStartResult, fidl::Error>>
        + Send;
    fn r#read_channel_streaming_start(
        &self,
        handle: &HandleId,
    ) -> Self::ReadChannelStreamingStartResponseFut;
    type ReadChannelStreamingStopResponseFut: std::future::Future<Output = Result<ChannelReadChannelStreamingStopResult, fidl::Error>>
        + Send;
    fn r#read_channel_streaming_stop(
        &self,
        handle: &HandleId,
    ) -> Self::ReadChannelStreamingStopResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ChannelSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ChannelSynchronousProxy {
    type Proxy = ChannelProxy;
    type Protocol = ChannelMarker;

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

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

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

    /// Create a new channel in this FDomain and return both its ends.
    pub fn r#create_channel(
        &self,
        mut handles: &[NewHandleId; 2],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ChannelCreateChannelResult, fidl::Error> {
        let _response = self.client.send_query::<
            ChannelCreateChannelRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            ChannelMarker,
        >(
            (handles,),
            0x182d38bfe88673b5,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ChannelMarker>("create_channel")?;
        Ok(_response.map(|x| x))
    }

    /// Read a message from a channel. This method will fail if the channel is currently being read
    /// using the streaming read functions.
    ///
    /// Note that this method is not like zx_channel_read in that it will not
    /// return `SHOULD_WAIT` but will instead delay returning until there is data
    /// to return.
    pub fn r#read_channel(
        &self,
        mut handle: &HandleId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ChannelReadChannelResult, fidl::Error> {
        let _response = self.client.send_query::<
            ChannelReadChannelRequest,
            fidl::encoding::FlexibleResultType<ChannelMessage, Error>,
            ChannelMarker,
        >(
            (handle,),
            0x6ef47bf27bf7d050,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ChannelMarker>("read_channel")?;
        Ok(_response.map(|x| (x.data, x.handles)))
    }

    /// Write to a channel. Handles are always consumed.
    pub fn r#write_channel(
        &self,
        mut handle: &HandleId,
        mut data: &[u8],
        mut handles: &Handles,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ChannelWriteChannelResult, fidl::Error> {
        let _response = self.client.send_query::<
            ChannelWriteChannelRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, WriteChannelError>,
            ChannelMarker,
        >(
            (handle, data, handles,),
            0x75a2559b945d5eb5,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ChannelMarker>("write_channel")?;
        Ok(_response.map(|x| x))
    }

    /// Starts reading from the given channel. Data is returned via the `ChannelStreamingData` event.
    /// That event will occur repeatedly until `ReadChannelStreamingStop` is called for the same handle
    /// or the event indicates the handle is closed.
    pub fn r#read_channel_streaming_start(
        &self,
        mut handle: &HandleId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ChannelReadChannelStreamingStartResult, fidl::Error> {
        let _response = self.client.send_query::<
            ChannelReadChannelStreamingStartRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            ChannelMarker,
        >(
            (handle,),
            0x3c73e85476a203df,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ChannelMarker>("read_channel_streaming_start")?;
        Ok(_response.map(|x| x))
    }

    /// Stop asynchronous reading from the given channel.
    pub fn r#read_channel_streaming_stop(
        &self,
        mut handle: &HandleId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ChannelReadChannelStreamingStopResult, fidl::Error> {
        let _response = self.client.send_query::<
            ChannelReadChannelStreamingStopRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            ChannelMarker,
        >(
            (handle,),
            0x56f21d6ed68186e0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<ChannelMarker>("read_channel_streaming_stop")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ChannelProxy {
    type Protocol = ChannelMarker;

    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 ChannelProxy {
    /// Create a new Proxy for fuchsia.fdomain/Channel.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ChannelMarker 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) -> ChannelEventStream {
        ChannelEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Create a new channel in this FDomain and return both its ends.
    pub fn r#create_channel(
        &self,
        mut handles: &[NewHandleId; 2],
    ) -> fidl::client::QueryResponseFut<
        ChannelCreateChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ChannelProxyInterface::r#create_channel(self, handles)
    }

    /// Read a message from a channel. This method will fail if the channel is currently being read
    /// using the streaming read functions.
    ///
    /// Note that this method is not like zx_channel_read in that it will not
    /// return `SHOULD_WAIT` but will instead delay returning until there is data
    /// to return.
    pub fn r#read_channel(
        &self,
        mut handle: &HandleId,
    ) -> fidl::client::QueryResponseFut<
        ChannelReadChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ChannelProxyInterface::r#read_channel(self, handle)
    }

    /// Write to a channel. Handles are always consumed.
    pub fn r#write_channel(
        &self,
        mut handle: &HandleId,
        mut data: &[u8],
        mut handles: &Handles,
    ) -> fidl::client::QueryResponseFut<
        ChannelWriteChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ChannelProxyInterface::r#write_channel(self, handle, data, handles)
    }

    /// Starts reading from the given channel. Data is returned via the `ChannelStreamingData` event.
    /// That event will occur repeatedly until `ReadChannelStreamingStop` is called for the same handle
    /// or the event indicates the handle is closed.
    pub fn r#read_channel_streaming_start(
        &self,
        mut handle: &HandleId,
    ) -> fidl::client::QueryResponseFut<
        ChannelReadChannelStreamingStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ChannelProxyInterface::r#read_channel_streaming_start(self, handle)
    }

    /// Stop asynchronous reading from the given channel.
    pub fn r#read_channel_streaming_stop(
        &self,
        mut handle: &HandleId,
    ) -> fidl::client::QueryResponseFut<
        ChannelReadChannelStreamingStopResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ChannelProxyInterface::r#read_channel_streaming_stop(self, handle)
    }
}

impl ChannelProxyInterface for ChannelProxy {
    type CreateChannelResponseFut = fidl::client::QueryResponseFut<
        ChannelCreateChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_channel(&self, mut handles: &[NewHandleId; 2]) -> Self::CreateChannelResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ChannelCreateChannelResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x182d38bfe88673b5,
            >(_buf?)?
            .into_result::<ChannelMarker>("create_channel")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<ChannelCreateChannelRequest, ChannelCreateChannelResult>(
                (handles,),
                0x182d38bfe88673b5,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type ReadChannelResponseFut = fidl::client::QueryResponseFut<
        ChannelReadChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_channel(&self, mut handle: &HandleId) -> Self::ReadChannelResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ChannelReadChannelResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ChannelMessage, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ef47bf27bf7d050,
            >(_buf?)?
            .into_result::<ChannelMarker>("read_channel")?;
            Ok(_response.map(|x| (x.data, x.handles)))
        }
        self.client.send_query_and_decode::<ChannelReadChannelRequest, ChannelReadChannelResult>(
            (handle,),
            0x6ef47bf27bf7d050,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type WriteChannelResponseFut = fidl::client::QueryResponseFut<
        ChannelWriteChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_channel(
        &self,
        mut handle: &HandleId,
        mut data: &[u8],
        mut handles: &Handles,
    ) -> Self::WriteChannelResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ChannelWriteChannelResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, WriteChannelError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x75a2559b945d5eb5,
            >(_buf?)?
            .into_result::<ChannelMarker>("write_channel")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<ChannelWriteChannelRequest, ChannelWriteChannelResult>(
            (handle, data, handles),
            0x75a2559b945d5eb5,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ReadChannelStreamingStartResponseFut = fidl::client::QueryResponseFut<
        ChannelReadChannelStreamingStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_channel_streaming_start(
        &self,
        mut handle: &HandleId,
    ) -> Self::ReadChannelStreamingStartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ChannelReadChannelStreamingStartResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3c73e85476a203df,
            >(_buf?)?
            .into_result::<ChannelMarker>("read_channel_streaming_start")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ChannelReadChannelStreamingStartRequest,
            ChannelReadChannelStreamingStartResult,
        >(
            (handle,),
            0x3c73e85476a203df,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ReadChannelStreamingStopResponseFut = fidl::client::QueryResponseFut<
        ChannelReadChannelStreamingStopResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_channel_streaming_stop(
        &self,
        mut handle: &HandleId,
    ) -> Self::ReadChannelStreamingStopResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ChannelReadChannelStreamingStopResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x56f21d6ed68186e0,
            >(_buf?)?
            .into_result::<ChannelMarker>("read_channel_streaming_stop")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ChannelReadChannelStreamingStopRequest,
            ChannelReadChannelStreamingStopResult,
        >(
            (handle,),
            0x56f21d6ed68186e0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum ChannelEvent {
    OnChannelStreamingData {
        handle: HandleId,
        channel_sent: ChannelSent,
    },
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl ChannelEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_channel_streaming_data(self) -> Option<(HandleId, ChannelSent)> {
        if let ChannelEvent::OnChannelStreamingData { handle, channel_sent } = self {
            Some((handle, channel_sent))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`ChannelEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ChannelEvent, 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 {
            0x7d4431805202dfe1 => {
                let mut out = fidl::new_empty!(
                    ChannelOnChannelStreamingDataRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelOnChannelStreamingDataRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((ChannelEvent::OnChannelStreamingData {
                    handle: out.handle,
                    channel_sent: out.channel_sent,
                }))
            }
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(ChannelEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <ChannelMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for ChannelRequestStream {
    type Protocol = ChannelMarker;
    type ControlHandle = ChannelControlHandle;

    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 {
        ChannelControlHandle { 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 ChannelRequestStream {
    type Item = Result<ChannelRequest, 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 ChannelRequestStream 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 {
                    0x182d38bfe88673b5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ChannelCreateChannelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelCreateChannelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ChannelControlHandle { inner: this.inner.clone() };
                        Ok(ChannelRequest::CreateChannel {
                            handles: req.handles,

                            responder: ChannelCreateChannelResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6ef47bf27bf7d050 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ChannelReadChannelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelReadChannelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ChannelControlHandle { inner: this.inner.clone() };
                        Ok(ChannelRequest::ReadChannel {
                            handle: req.handle,

                            responder: ChannelReadChannelResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x75a2559b945d5eb5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ChannelWriteChannelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelWriteChannelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ChannelControlHandle { inner: this.inner.clone() };
                        Ok(ChannelRequest::WriteChannel {
                            handle: req.handle,
                            data: req.data,
                            handles: req.handles,

                            responder: ChannelWriteChannelResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3c73e85476a203df => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ChannelReadChannelStreamingStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelReadChannelStreamingStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ChannelControlHandle { inner: this.inner.clone() };
                        Ok(ChannelRequest::ReadChannelStreamingStart {
                            handle: req.handle,

                            responder: ChannelReadChannelStreamingStartResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x56f21d6ed68186e0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ChannelReadChannelStreamingStopRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelReadChannelStreamingStopRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ChannelControlHandle { inner: this.inner.clone() };
                        Ok(ChannelRequest::ReadChannelStreamingStop {
                            handle: req.handle,

                            responder: ChannelReadChannelStreamingStopResponder {
                                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(ChannelRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ChannelControlHandle { 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(ChannelRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: ChannelControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ChannelMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// FDomain operations on Channels.
#[derive(Debug)]
pub enum ChannelRequest {
    /// Create a new channel in this FDomain and return both its ends.
    CreateChannel { handles: [NewHandleId; 2], responder: ChannelCreateChannelResponder },
    /// Read a message from a channel. This method will fail if the channel is currently being read
    /// using the streaming read functions.
    ///
    /// Note that this method is not like zx_channel_read in that it will not
    /// return `SHOULD_WAIT` but will instead delay returning until there is data
    /// to return.
    ReadChannel { handle: HandleId, responder: ChannelReadChannelResponder },
    /// Write to a channel. Handles are always consumed.
    WriteChannel {
        handle: HandleId,
        data: Vec<u8>,
        handles: Handles,
        responder: ChannelWriteChannelResponder,
    },
    /// Starts reading from the given channel. Data is returned via the `ChannelStreamingData` event.
    /// That event will occur repeatedly until `ReadChannelStreamingStop` is called for the same handle
    /// or the event indicates the handle is closed.
    ReadChannelStreamingStart {
        handle: HandleId,
        responder: ChannelReadChannelStreamingStartResponder,
    },
    /// Stop asynchronous reading from the given channel.
    ReadChannelStreamingStop {
        handle: HandleId,
        responder: ChannelReadChannelStreamingStopResponder,
    },
    /// 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: ChannelControlHandle,
        method_type: fidl::MethodType,
    },
}

impl ChannelRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_channel(self) -> Option<([NewHandleId; 2], ChannelCreateChannelResponder)> {
        if let ChannelRequest::CreateChannel { handles, responder } = self {
            Some((handles, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_channel(self) -> Option<(HandleId, ChannelReadChannelResponder)> {
        if let ChannelRequest::ReadChannel { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_channel(
        self,
    ) -> Option<(HandleId, Vec<u8>, Handles, ChannelWriteChannelResponder)> {
        if let ChannelRequest::WriteChannel { handle, data, handles, responder } = self {
            Some((handle, data, handles, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_channel_streaming_start(
        self,
    ) -> Option<(HandleId, ChannelReadChannelStreamingStartResponder)> {
        if let ChannelRequest::ReadChannelStreamingStart { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_channel_streaming_stop(
        self,
    ) -> Option<(HandleId, ChannelReadChannelStreamingStopResponder)> {
        if let ChannelRequest::ReadChannelStreamingStop { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ChannelRequest::CreateChannel { .. } => "create_channel",
            ChannelRequest::ReadChannel { .. } => "read_channel",
            ChannelRequest::WriteChannel { .. } => "write_channel",
            ChannelRequest::ReadChannelStreamingStart { .. } => "read_channel_streaming_start",
            ChannelRequest::ReadChannelStreamingStop { .. } => "read_channel_streaming_stop",
            ChannelRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            ChannelRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

impl fidl::endpoints::ControlHandle for ChannelControlHandle {
    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 ChannelControlHandle {
    pub fn send_on_channel_streaming_data(
        &self,
        mut handle: &HandleId,
        mut channel_sent: &ChannelSent,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<ChannelOnChannelStreamingDataRequest>(
            (handle, channel_sent),
            0,
            0x7d4431805202dfe1,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &ChannelControlHandle {
        &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 ChannelCreateChannelResponder {
    /// 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,
            0x182d38bfe88673b5,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut result: Result<(&[u8], &[HandleInfo]), &Error>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<ChannelMessage, Error>>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x6ef47bf27bf7d050,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

    fn control_handle(&self) -> &ChannelControlHandle {
        &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 ChannelReadChannelStreamingStartResponder {
    /// 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,
            0x3c73e85476a203df,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &ChannelControlHandle {
        &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 ChannelReadChannelStreamingStopResponder {
    /// 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,
            0x56f21d6ed68186e0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for EventMarker {
    type Proxy = EventProxy;
    type RequestStream = EventRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = EventSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Event";
}
pub type EventCreateEventResult = Result<(), Error>;

pub trait EventProxyInterface: Send + Sync {
    type CreateEventResponseFut: std::future::Future<Output = Result<EventCreateEventResult, fidl::Error>>
        + Send;
    fn r#create_event(&self, handle: &NewHandleId) -> Self::CreateEventResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct EventSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for EventSynchronousProxy {
    type Proxy = EventProxy;
    type Protocol = EventMarker;

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

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

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

    /// Create a new event in this FDomain and return it.
    pub fn r#create_event(
        &self,
        mut handle: &NewHandleId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EventCreateEventResult, fidl::Error> {
        let _response = self.client.send_query::<
            EventCreateEventRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            EventMarker,
        >(
            (handle,),
            0x7b05b3f262635987,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<EventMarker>("create_event")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for EventProxy {
    type Protocol = EventMarker;

    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 EventProxy {
    /// Create a new Proxy for fuchsia.fdomain/Event.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <EventMarker 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) -> EventEventStream {
        EventEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Create a new event in this FDomain and return it.
    pub fn r#create_event(
        &self,
        mut handle: &NewHandleId,
    ) -> fidl::client::QueryResponseFut<
        EventCreateEventResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        EventProxyInterface::r#create_event(self, handle)
    }
}

impl EventProxyInterface for EventProxy {
    type CreateEventResponseFut = fidl::client::QueryResponseFut<
        EventCreateEventResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_event(&self, mut handle: &NewHandleId) -> Self::CreateEventResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EventCreateEventResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7b05b3f262635987,
            >(_buf?)?
            .into_result::<EventMarker>("create_event")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<EventCreateEventRequest, EventCreateEventResult>(
            (handle,),
            0x7b05b3f262635987,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

impl EventEvent {
    /// Decodes a message buffer as a [`EventEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<EventEvent, 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(EventEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <EventMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for EventRequestStream {
    type Protocol = EventMarker;
    type ControlHandle = EventControlHandle;

    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 {
        EventControlHandle { 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 EventRequestStream {
    type Item = Result<EventRequest, 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 EventRequestStream 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 {
                    0x7b05b3f262635987 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            EventCreateEventRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EventCreateEventRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = EventControlHandle { inner: this.inner.clone() };
                        Ok(EventRequest::CreateEvent {
                            handle: req.handle,

                            responder: EventCreateEventResponder {
                                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(EventRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: EventControlHandle { 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(EventRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: EventControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name: <EventMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// FDomain operations on Events.
#[derive(Debug)]
pub enum EventRequest {
    /// Create a new event in this FDomain and return it.
    CreateEvent { handle: NewHandleId, responder: EventCreateEventResponder },
    /// 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: EventControlHandle,
        method_type: fidl::MethodType,
    },
}

impl EventRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_event(self) -> Option<(NewHandleId, EventCreateEventResponder)> {
        if let EventRequest::CreateEvent { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

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

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

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

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

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

    fn control_handle(&self) -> &EventControlHandle {
        &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 EventCreateEventResponder {
    /// 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,
            0x7b05b3f262635987,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for EventPairMarker {
    type Proxy = EventPairProxy;
    type RequestStream = EventPairRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = EventPairSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) EventPair";
}
pub type EventPairCreateEventPairResult = Result<(), Error>;

pub trait EventPairProxyInterface: Send + Sync {
    type CreateEventPairResponseFut: std::future::Future<Output = Result<EventPairCreateEventPairResult, fidl::Error>>
        + Send;
    fn r#create_event_pair(&self, handles: &[NewHandleId; 2]) -> Self::CreateEventPairResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct EventPairSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for EventPairSynchronousProxy {
    type Proxy = EventPairProxy;
    type Protocol = EventPairMarker;

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

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

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

    /// Create a new event pair in this FDomain and return both its ends.
    pub fn r#create_event_pair(
        &self,
        mut handles: &[NewHandleId; 2],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EventPairCreateEventPairResult, fidl::Error> {
        let _response = self.client.send_query::<
            EventPairCreateEventPairRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            EventPairMarker,
        >(
            (handles,),
            0x7aef61effa65656d,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<EventPairMarker>("create_event_pair")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for EventPairProxy {
    type Protocol = EventPairMarker;

    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 EventPairProxy {
    /// Create a new Proxy for fuchsia.fdomain/EventPair.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <EventPairMarker 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) -> EventPairEventStream {
        EventPairEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Create a new event pair in this FDomain and return both its ends.
    pub fn r#create_event_pair(
        &self,
        mut handles: &[NewHandleId; 2],
    ) -> fidl::client::QueryResponseFut<
        EventPairCreateEventPairResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        EventPairProxyInterface::r#create_event_pair(self, handles)
    }
}

impl EventPairProxyInterface for EventPairProxy {
    type CreateEventPairResponseFut = fidl::client::QueryResponseFut<
        EventPairCreateEventPairResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_event_pair(
        &self,
        mut handles: &[NewHandleId; 2],
    ) -> Self::CreateEventPairResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EventPairCreateEventPairResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7aef61effa65656d,
            >(_buf?)?
            .into_result::<EventPairMarker>("create_event_pair")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            EventPairCreateEventPairRequest,
            EventPairCreateEventPairResult,
        >(
            (handles,),
            0x7aef61effa65656d,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

impl EventPairEvent {
    /// Decodes a message buffer as a [`EventPairEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<EventPairEvent, 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(EventPairEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <EventPairMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for EventPairRequestStream {
    type Protocol = EventPairMarker;
    type ControlHandle = EventPairControlHandle;

    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 {
        EventPairControlHandle { 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 EventPairRequestStream {
    type Item = Result<EventPairRequest, 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 EventPairRequestStream 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 {
                    0x7aef61effa65656d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            EventPairCreateEventPairRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EventPairCreateEventPairRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = EventPairControlHandle { inner: this.inner.clone() };
                        Ok(EventPairRequest::CreateEventPair {
                            handles: req.handles,

                            responder: EventPairCreateEventPairResponder {
                                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(EventPairRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: EventPairControlHandle { 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(EventPairRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: EventPairControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <EventPairMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// FDomain operations on EventPairs.
#[derive(Debug)]
pub enum EventPairRequest {
    /// Create a new event pair in this FDomain and return both its ends.
    CreateEventPair { handles: [NewHandleId; 2], responder: EventPairCreateEventPairResponder },
    /// 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: EventPairControlHandle,
        method_type: fidl::MethodType,
    },
}

impl EventPairRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_event_pair(
        self,
    ) -> Option<([NewHandleId; 2], EventPairCreateEventPairResponder)> {
        if let EventPairRequest::CreateEventPair { handles, responder } = self {
            Some((handles, responder))
        } else {
            None
        }
    }

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

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

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

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

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

    fn control_handle(&self) -> &EventPairControlHandle {
        &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 EventPairCreateEventPairResponder {
    /// 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,
            0x7aef61effa65656d,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for FDomainMarker {
    type Proxy = FDomainProxy;
    type RequestStream = FDomainRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = FDomainSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) FDomain";
}
pub type FDomainGetNamespaceResult = Result<(), Error>;
pub type FDomainCloseResult = Result<(), Error>;
pub type FDomainDuplicateResult = Result<(), Error>;
pub type FDomainReplaceResult = Result<(), Error>;
pub type FDomainSignalResult = Result<(), Error>;
pub type FDomainSignalPeerResult = Result<(), Error>;
pub type FDomainWaitForSignalsResult = Result<u32, Error>;
pub type FDomainGetKoidResult = Result<u64, Error>;

pub trait FDomainProxyInterface: Send + Sync {
    type CreateChannelResponseFut: std::future::Future<Output = Result<ChannelCreateChannelResult, fidl::Error>>
        + Send;
    fn r#create_channel(&self, handles: &[NewHandleId; 2]) -> Self::CreateChannelResponseFut;
    type ReadChannelResponseFut: std::future::Future<Output = Result<ChannelReadChannelResult, fidl::Error>>
        + Send;
    fn r#read_channel(&self, handle: &HandleId) -> Self::ReadChannelResponseFut;
    type WriteChannelResponseFut: std::future::Future<Output = Result<ChannelWriteChannelResult, fidl::Error>>
        + Send;
    fn r#write_channel(
        &self,
        handle: &HandleId,
        data: &[u8],
        handles: &Handles,
    ) -> Self::WriteChannelResponseFut;
    type ReadChannelStreamingStartResponseFut: std::future::Future<Output = Result<ChannelReadChannelStreamingStartResult, fidl::Error>>
        + Send;
    fn r#read_channel_streaming_start(
        &self,
        handle: &HandleId,
    ) -> Self::ReadChannelStreamingStartResponseFut;
    type ReadChannelStreamingStopResponseFut: std::future::Future<Output = Result<ChannelReadChannelStreamingStopResult, fidl::Error>>
        + Send;
    fn r#read_channel_streaming_stop(
        &self,
        handle: &HandleId,
    ) -> Self::ReadChannelStreamingStopResponseFut;
    type CreateEventResponseFut: std::future::Future<Output = Result<EventCreateEventResult, fidl::Error>>
        + Send;
    fn r#create_event(&self, handle: &NewHandleId) -> Self::CreateEventResponseFut;
    type CreateEventPairResponseFut: std::future::Future<Output = Result<EventPairCreateEventPairResult, fidl::Error>>
        + Send;
    fn r#create_event_pair(&self, handles: &[NewHandleId; 2]) -> Self::CreateEventPairResponseFut;
    type CreateSocketResponseFut: std::future::Future<Output = Result<SocketCreateSocketResult, fidl::Error>>
        + Send;
    fn r#create_socket(
        &self,
        options: SocketType,
        handles: &[NewHandleId; 2],
    ) -> Self::CreateSocketResponseFut;
    type SetSocketDispositionResponseFut: std::future::Future<Output = Result<SocketSetSocketDispositionResult, fidl::Error>>
        + Send;
    fn r#set_socket_disposition(
        &self,
        handle: &HandleId,
        disposition: SocketDisposition,
        disposition_peer: SocketDisposition,
    ) -> Self::SetSocketDispositionResponseFut;
    type ReadSocketResponseFut: std::future::Future<Output = Result<SocketReadSocketResult, fidl::Error>>
        + Send;
    fn r#read_socket(&self, handle: &HandleId, max_bytes: u64) -> Self::ReadSocketResponseFut;
    type WriteSocketResponseFut: std::future::Future<Output = Result<SocketWriteSocketResult, fidl::Error>>
        + Send;
    fn r#write_socket(&self, handle: &HandleId, data: &[u8]) -> Self::WriteSocketResponseFut;
    type ReadSocketStreamingStartResponseFut: std::future::Future<Output = Result<SocketReadSocketStreamingStartResult, fidl::Error>>
        + Send;
    fn r#read_socket_streaming_start(
        &self,
        handle: &HandleId,
    ) -> Self::ReadSocketStreamingStartResponseFut;
    type ReadSocketStreamingStopResponseFut: std::future::Future<Output = Result<SocketReadSocketStreamingStopResult, fidl::Error>>
        + Send;
    fn r#read_socket_streaming_stop(
        &self,
        handle: &HandleId,
    ) -> Self::ReadSocketStreamingStopResponseFut;
    type GetNamespaceResponseFut: std::future::Future<Output = Result<FDomainGetNamespaceResult, fidl::Error>>
        + Send;
    fn r#get_namespace(&self, new_handle: &NewHandleId) -> Self::GetNamespaceResponseFut;
    type CloseResponseFut: std::future::Future<Output = Result<FDomainCloseResult, fidl::Error>>
        + Send;
    fn r#close(&self, handles: &[HandleId]) -> Self::CloseResponseFut;
    type DuplicateResponseFut: std::future::Future<Output = Result<FDomainDuplicateResult, fidl::Error>>
        + Send;
    fn r#duplicate(
        &self,
        handle: &HandleId,
        new_handle: &NewHandleId,
        rights: fidl::Rights,
    ) -> Self::DuplicateResponseFut;
    type ReplaceResponseFut: std::future::Future<Output = Result<FDomainReplaceResult, fidl::Error>>
        + Send;
    fn r#replace(
        &self,
        handle: &HandleId,
        new_handle: &NewHandleId,
        rights: fidl::Rights,
    ) -> Self::ReplaceResponseFut;
    type SignalResponseFut: std::future::Future<Output = Result<FDomainSignalResult, fidl::Error>>
        + Send;
    fn r#signal(&self, handle: &HandleId, set: u32, clear: u32) -> Self::SignalResponseFut;
    type SignalPeerResponseFut: std::future::Future<Output = Result<FDomainSignalPeerResult, fidl::Error>>
        + Send;
    fn r#signal_peer(&self, handle: &HandleId, set: u32, clear: u32)
    -> Self::SignalPeerResponseFut;
    type WaitForSignalsResponseFut: std::future::Future<Output = Result<FDomainWaitForSignalsResult, fidl::Error>>
        + Send;
    fn r#wait_for_signals(
        &self,
        handle: &HandleId,
        signals: u32,
    ) -> Self::WaitForSignalsResponseFut;
    type GetKoidResponseFut: std::future::Future<Output = Result<FDomainGetKoidResult, fidl::Error>>
        + Send;
    fn r#get_koid(&self, handle: &HandleId) -> Self::GetKoidResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct FDomainSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for FDomainSynchronousProxy {
    type Proxy = FDomainProxy;
    type Protocol = FDomainMarker;

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

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

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

    /// Create a new channel in this FDomain and return both its ends.
    pub fn r#create_channel(
        &self,
        mut handles: &[NewHandleId; 2],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ChannelCreateChannelResult, fidl::Error> {
        let _response = self.client.send_query::<
            ChannelCreateChannelRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            FDomainMarker,
        >(
            (handles,),
            0x182d38bfe88673b5,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("create_channel")?;
        Ok(_response.map(|x| x))
    }

    /// Read a message from a channel. This method will fail if the channel is currently being read
    /// using the streaming read functions.
    ///
    /// Note that this method is not like zx_channel_read in that it will not
    /// return `SHOULD_WAIT` but will instead delay returning until there is data
    /// to return.
    pub fn r#read_channel(
        &self,
        mut handle: &HandleId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ChannelReadChannelResult, fidl::Error> {
        let _response = self.client.send_query::<
            ChannelReadChannelRequest,
            fidl::encoding::FlexibleResultType<ChannelMessage, Error>,
            FDomainMarker,
        >(
            (handle,),
            0x6ef47bf27bf7d050,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("read_channel")?;
        Ok(_response.map(|x| (x.data, x.handles)))
    }

    /// Write to a channel. Handles are always consumed.
    pub fn r#write_channel(
        &self,
        mut handle: &HandleId,
        mut data: &[u8],
        mut handles: &Handles,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ChannelWriteChannelResult, fidl::Error> {
        let _response = self.client.send_query::<
            ChannelWriteChannelRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, WriteChannelError>,
            FDomainMarker,
        >(
            (handle, data, handles,),
            0x75a2559b945d5eb5,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("write_channel")?;
        Ok(_response.map(|x| x))
    }

    /// Starts reading from the given channel. Data is returned via the `ChannelStreamingData` event.
    /// That event will occur repeatedly until `ReadChannelStreamingStop` is called for the same handle
    /// or the event indicates the handle is closed.
    pub fn r#read_channel_streaming_start(
        &self,
        mut handle: &HandleId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ChannelReadChannelStreamingStartResult, fidl::Error> {
        let _response = self.client.send_query::<
            ChannelReadChannelStreamingStartRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            FDomainMarker,
        >(
            (handle,),
            0x3c73e85476a203df,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("read_channel_streaming_start")?;
        Ok(_response.map(|x| x))
    }

    /// Stop asynchronous reading from the given channel.
    pub fn r#read_channel_streaming_stop(
        &self,
        mut handle: &HandleId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ChannelReadChannelStreamingStopResult, fidl::Error> {
        let _response = self.client.send_query::<
            ChannelReadChannelStreamingStopRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            FDomainMarker,
        >(
            (handle,),
            0x56f21d6ed68186e0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("read_channel_streaming_stop")?;
        Ok(_response.map(|x| x))
    }

    /// Create a new event in this FDomain and return it.
    pub fn r#create_event(
        &self,
        mut handle: &NewHandleId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EventCreateEventResult, fidl::Error> {
        let _response = self.client.send_query::<
            EventCreateEventRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            FDomainMarker,
        >(
            (handle,),
            0x7b05b3f262635987,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("create_event")?;
        Ok(_response.map(|x| x))
    }

    /// Create a new event pair in this FDomain and return both its ends.
    pub fn r#create_event_pair(
        &self,
        mut handles: &[NewHandleId; 2],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EventPairCreateEventPairResult, fidl::Error> {
        let _response = self.client.send_query::<
            EventPairCreateEventPairRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            FDomainMarker,
        >(
            (handles,),
            0x7aef61effa65656d,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("create_event_pair")?;
        Ok(_response.map(|x| x))
    }

    /// Create a new socket in this FDomain and return both its ends.
    pub fn r#create_socket(
        &self,
        mut options: SocketType,
        mut handles: &[NewHandleId; 2],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SocketCreateSocketResult, fidl::Error> {
        let _response = self.client.send_query::<
            SocketCreateSocketRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            FDomainMarker,
        >(
            (options, handles,),
            0x200bf0ea21932de0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("create_socket")?;
        Ok(_response.map(|x| x))
    }

    /// Set the disposition of a given socket.
    pub fn r#set_socket_disposition(
        &self,
        mut handle: &HandleId,
        mut disposition: SocketDisposition,
        mut disposition_peer: SocketDisposition,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SocketSetSocketDispositionResult, fidl::Error> {
        let _response = self.client.send_query::<
            SocketSetSocketDispositionRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            FDomainMarker,
        >(
            (handle, disposition, disposition_peer,),
            0x60d3c7ccb17f9bdf,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("set_socket_disposition")?;
        Ok(_response.map(|x| x))
    }

    /// Read data from a socket. This method will fail if the socket is currently being read
    /// asynchronously.
    pub fn r#read_socket(
        &self,
        mut handle: &HandleId,
        mut max_bytes: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SocketReadSocketResult, fidl::Error> {
        let _response = self.client.send_query::<
            SocketReadSocketRequest,
            fidl::encoding::FlexibleResultType<SocketData, Error>,
            FDomainMarker,
        >(
            (handle, max_bytes,),
            0x1da8aabec249c02e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("read_socket")?;
        Ok(_response.map(|x| (x.data, x.is_datagram)))
    }

    /// Write to a socket. This will attempt to write all the data passed, and
    /// will block and retry whenever it is safe (e.g. it should never return
    /// SHOULD_WAIT). The `WriteSocketError` contains a `wrote` parameter to
    /// indicate if some bytes were written successfully before the failure
    /// occurred.
    pub fn r#write_socket(
        &self,
        mut handle: &HandleId,
        mut data: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SocketWriteSocketResult, fidl::Error> {
        let _response = self.client.send_query::<
            SocketWriteSocketRequest,
            fidl::encoding::FlexibleResultType<SocketWriteSocketResponse, WriteSocketError>,
            FDomainMarker,
        >(
            (handle, data,),
            0x5b541623cbbbf683,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("write_socket")?;
        Ok(_response.map(|x| x.wrote))
    }

    /// Starts reading from the given socket. Data is returned via the `SocketStreamingData` event. That
    /// event will occur repeatedly until `ReadSocketStreamingStop` is called for the same handle or the
    /// event indicates the handle is closed.
    pub fn r#read_socket_streaming_start(
        &self,
        mut handle: &HandleId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SocketReadSocketStreamingStartResult, fidl::Error> {
        let _response = self.client.send_query::<
            SocketReadSocketStreamingStartRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            FDomainMarker,
        >(
            (handle,),
            0x2a592748d5f33445,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("read_socket_streaming_start")?;
        Ok(_response.map(|x| x))
    }

    /// Stop asynchronous reading from the given socket.
    pub fn r#read_socket_streaming_stop(
        &self,
        mut handle: &HandleId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SocketReadSocketStreamingStopResult, fidl::Error> {
        let _response = self.client.send_query::<
            SocketReadSocketStreamingStopRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            FDomainMarker,
        >(
            (handle,),
            0x53e5cade5f4d22e7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("read_socket_streaming_stop")?;
        Ok(_response.map(|x| x))
    }

    /// Adds a new channel handle to this namespace which points to a
    /// fuchsia.io.Directory. Can be used to "bootstrap" the FDomain.
    pub fn r#get_namespace(
        &self,
        mut new_handle: &NewHandleId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FDomainGetNamespaceResult, fidl::Error> {
        let _response = self.client.send_query::<
            FDomainGetNamespaceRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            FDomainMarker,
        >(
            (new_handle,),
            0x74f2e74d9f53e11e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("get_namespace")?;
        Ok(_response.map(|x| x))
    }

    /// Close one or more handles.
    pub fn r#close(
        &self,
        mut handles: &[HandleId],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FDomainCloseResult, fidl::Error> {
        let _response = self.client.send_query::<
            FDomainCloseRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            FDomainMarker,
        >(
            (handles,),
            0x5ef8c24362964257,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("close")?;
        Ok(_response.map(|x| x))
    }

    /// Duplicate a handle.
    pub fn r#duplicate(
        &self,
        mut handle: &HandleId,
        mut new_handle: &NewHandleId,
        mut rights: fidl::Rights,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FDomainDuplicateResult, fidl::Error> {
        let _response = self.client.send_query::<
            FDomainDuplicateRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            FDomainMarker,
        >(
            (handle, new_handle, rights,),
            0x7a85b94bd1777ab9,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("duplicate")?;
        Ok(_response.map(|x| x))
    }

    /// Close a handle and replace it with a new one with possibly different
    /// rights.
    pub fn r#replace(
        &self,
        mut handle: &HandleId,
        mut new_handle: &NewHandleId,
        mut rights: fidl::Rights,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FDomainReplaceResult, fidl::Error> {
        let _response = self.client.send_query::<
            FDomainReplaceRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            FDomainMarker,
        >(
            (handle, new_handle, rights,),
            0x32fa64625a5bd3be,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("replace")?;
        Ok(_response.map(|x| x))
    }

    /// Set or clear signals on a handle.
    pub fn r#signal(
        &self,
        mut handle: &HandleId,
        mut set: u32,
        mut clear: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FDomainSignalResult, fidl::Error> {
        let _response = self.client.send_query::<
            FDomainSignalRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            FDomainMarker,
        >(
            (handle, set, clear,),
            0xe8352fb978996d9,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("signal")?;
        Ok(_response.map(|x| x))
    }

    /// Set or clear signals on a handle's peer.
    pub fn r#signal_peer(
        &self,
        mut handle: &HandleId,
        mut set: u32,
        mut clear: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FDomainSignalPeerResult, fidl::Error> {
        let _response = self.client.send_query::<
            FDomainSignalPeerRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            FDomainMarker,
        >(
            (handle, set, clear,),
            0x7e84ec8ca7eabaf8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("signal_peer")?;
        Ok(_response.map(|x| x))
    }

    /// Wait for signals from the given handle. Reply will be returned when one
    /// of the given signals is asserted.
    pub fn r#wait_for_signals(
        &self,
        mut handle: &HandleId,
        mut signals: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FDomainWaitForSignalsResult, fidl::Error> {
        let _response = self.client.send_query::<
            FDomainWaitForSignalsRequest,
            fidl::encoding::FlexibleResultType<FDomainWaitForSignalsResponse, Error>,
            FDomainMarker,
        >(
            (handle, signals,),
            0x8f72d9b4b85c1eb,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("wait_for_signals")?;
        Ok(_response.map(|x| x.signals))
    }

    /// Return the kernel object ID (koid) of the handle.
    pub fn r#get_koid(
        &self,
        mut handle: &HandleId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FDomainGetKoidResult, fidl::Error> {
        let _response = self.client.send_query::<
            FDomainGetKoidRequest,
            fidl::encoding::FlexibleResultType<FDomainGetKoidResponse, Error>,
            FDomainMarker,
        >(
            (handle,),
            0x437db979a63402c3,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<FDomainMarker>("get_koid")?;
        Ok(_response.map(|x| x.koid))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for FDomainProxy {
    type Protocol = FDomainMarker;

    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 FDomainProxy {
    /// Create a new Proxy for fuchsia.fdomain/FDomain.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <FDomainMarker 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) -> FDomainEventStream {
        FDomainEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Create a new channel in this FDomain and return both its ends.
    pub fn r#create_channel(
        &self,
        mut handles: &[NewHandleId; 2],
    ) -> fidl::client::QueryResponseFut<
        ChannelCreateChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#create_channel(self, handles)
    }

    /// Read a message from a channel. This method will fail if the channel is currently being read
    /// using the streaming read functions.
    ///
    /// Note that this method is not like zx_channel_read in that it will not
    /// return `SHOULD_WAIT` but will instead delay returning until there is data
    /// to return.
    pub fn r#read_channel(
        &self,
        mut handle: &HandleId,
    ) -> fidl::client::QueryResponseFut<
        ChannelReadChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#read_channel(self, handle)
    }

    /// Write to a channel. Handles are always consumed.
    pub fn r#write_channel(
        &self,
        mut handle: &HandleId,
        mut data: &[u8],
        mut handles: &Handles,
    ) -> fidl::client::QueryResponseFut<
        ChannelWriteChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#write_channel(self, handle, data, handles)
    }

    /// Starts reading from the given channel. Data is returned via the `ChannelStreamingData` event.
    /// That event will occur repeatedly until `ReadChannelStreamingStop` is called for the same handle
    /// or the event indicates the handle is closed.
    pub fn r#read_channel_streaming_start(
        &self,
        mut handle: &HandleId,
    ) -> fidl::client::QueryResponseFut<
        ChannelReadChannelStreamingStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#read_channel_streaming_start(self, handle)
    }

    /// Stop asynchronous reading from the given channel.
    pub fn r#read_channel_streaming_stop(
        &self,
        mut handle: &HandleId,
    ) -> fidl::client::QueryResponseFut<
        ChannelReadChannelStreamingStopResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#read_channel_streaming_stop(self, handle)
    }

    /// Create a new event in this FDomain and return it.
    pub fn r#create_event(
        &self,
        mut handle: &NewHandleId,
    ) -> fidl::client::QueryResponseFut<
        EventCreateEventResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#create_event(self, handle)
    }

    /// Create a new event pair in this FDomain and return both its ends.
    pub fn r#create_event_pair(
        &self,
        mut handles: &[NewHandleId; 2],
    ) -> fidl::client::QueryResponseFut<
        EventPairCreateEventPairResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#create_event_pair(self, handles)
    }

    /// Create a new socket in this FDomain and return both its ends.
    pub fn r#create_socket(
        &self,
        mut options: SocketType,
        mut handles: &[NewHandleId; 2],
    ) -> fidl::client::QueryResponseFut<
        SocketCreateSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#create_socket(self, options, handles)
    }

    /// Set the disposition of a given socket.
    pub fn r#set_socket_disposition(
        &self,
        mut handle: &HandleId,
        mut disposition: SocketDisposition,
        mut disposition_peer: SocketDisposition,
    ) -> fidl::client::QueryResponseFut<
        SocketSetSocketDispositionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#set_socket_disposition(self, handle, disposition, disposition_peer)
    }

    /// Read data from a socket. This method will fail if the socket is currently being read
    /// asynchronously.
    pub fn r#read_socket(
        &self,
        mut handle: &HandleId,
        mut max_bytes: u64,
    ) -> fidl::client::QueryResponseFut<
        SocketReadSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#read_socket(self, handle, max_bytes)
    }

    /// Write to a socket. This will attempt to write all the data passed, and
    /// will block and retry whenever it is safe (e.g. it should never return
    /// SHOULD_WAIT). The `WriteSocketError` contains a `wrote` parameter to
    /// indicate if some bytes were written successfully before the failure
    /// occurred.
    pub fn r#write_socket(
        &self,
        mut handle: &HandleId,
        mut data: &[u8],
    ) -> fidl::client::QueryResponseFut<
        SocketWriteSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#write_socket(self, handle, data)
    }

    /// Starts reading from the given socket. Data is returned via the `SocketStreamingData` event. That
    /// event will occur repeatedly until `ReadSocketStreamingStop` is called for the same handle or the
    /// event indicates the handle is closed.
    pub fn r#read_socket_streaming_start(
        &self,
        mut handle: &HandleId,
    ) -> fidl::client::QueryResponseFut<
        SocketReadSocketStreamingStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#read_socket_streaming_start(self, handle)
    }

    /// Stop asynchronous reading from the given socket.
    pub fn r#read_socket_streaming_stop(
        &self,
        mut handle: &HandleId,
    ) -> fidl::client::QueryResponseFut<
        SocketReadSocketStreamingStopResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#read_socket_streaming_stop(self, handle)
    }

    /// Adds a new channel handle to this namespace which points to a
    /// fuchsia.io.Directory. Can be used to "bootstrap" the FDomain.
    pub fn r#get_namespace(
        &self,
        mut new_handle: &NewHandleId,
    ) -> fidl::client::QueryResponseFut<
        FDomainGetNamespaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#get_namespace(self, new_handle)
    }

    /// Close one or more handles.
    pub fn r#close(
        &self,
        mut handles: &[HandleId],
    ) -> fidl::client::QueryResponseFut<
        FDomainCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#close(self, handles)
    }

    /// Duplicate a handle.
    pub fn r#duplicate(
        &self,
        mut handle: &HandleId,
        mut new_handle: &NewHandleId,
        mut rights: fidl::Rights,
    ) -> fidl::client::QueryResponseFut<
        FDomainDuplicateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#duplicate(self, handle, new_handle, rights)
    }

    /// Close a handle and replace it with a new one with possibly different
    /// rights.
    pub fn r#replace(
        &self,
        mut handle: &HandleId,
        mut new_handle: &NewHandleId,
        mut rights: fidl::Rights,
    ) -> fidl::client::QueryResponseFut<
        FDomainReplaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#replace(self, handle, new_handle, rights)
    }

    /// Set or clear signals on a handle.
    pub fn r#signal(
        &self,
        mut handle: &HandleId,
        mut set: u32,
        mut clear: u32,
    ) -> fidl::client::QueryResponseFut<
        FDomainSignalResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#signal(self, handle, set, clear)
    }

    /// Set or clear signals on a handle's peer.
    pub fn r#signal_peer(
        &self,
        mut handle: &HandleId,
        mut set: u32,
        mut clear: u32,
    ) -> fidl::client::QueryResponseFut<
        FDomainSignalPeerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#signal_peer(self, handle, set, clear)
    }

    /// Wait for signals from the given handle. Reply will be returned when one
    /// of the given signals is asserted.
    pub fn r#wait_for_signals(
        &self,
        mut handle: &HandleId,
        mut signals: u32,
    ) -> fidl::client::QueryResponseFut<
        FDomainWaitForSignalsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#wait_for_signals(self, handle, signals)
    }

    /// Return the kernel object ID (koid) of the handle.
    pub fn r#get_koid(
        &self,
        mut handle: &HandleId,
    ) -> fidl::client::QueryResponseFut<
        FDomainGetKoidResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FDomainProxyInterface::r#get_koid(self, handle)
    }
}

impl FDomainProxyInterface for FDomainProxy {
    type CreateChannelResponseFut = fidl::client::QueryResponseFut<
        ChannelCreateChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_channel(&self, mut handles: &[NewHandleId; 2]) -> Self::CreateChannelResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ChannelCreateChannelResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x182d38bfe88673b5,
            >(_buf?)?
            .into_result::<FDomainMarker>("create_channel")?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<ChannelCreateChannelRequest, ChannelCreateChannelResult>(
                (handles,),
                0x182d38bfe88673b5,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type ReadChannelResponseFut = fidl::client::QueryResponseFut<
        ChannelReadChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_channel(&self, mut handle: &HandleId) -> Self::ReadChannelResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ChannelReadChannelResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<ChannelMessage, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ef47bf27bf7d050,
            >(_buf?)?
            .into_result::<FDomainMarker>("read_channel")?;
            Ok(_response.map(|x| (x.data, x.handles)))
        }
        self.client.send_query_and_decode::<ChannelReadChannelRequest, ChannelReadChannelResult>(
            (handle,),
            0x6ef47bf27bf7d050,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type WriteChannelResponseFut = fidl::client::QueryResponseFut<
        ChannelWriteChannelResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_channel(
        &self,
        mut handle: &HandleId,
        mut data: &[u8],
        mut handles: &Handles,
    ) -> Self::WriteChannelResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ChannelWriteChannelResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, WriteChannelError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x75a2559b945d5eb5,
            >(_buf?)?
            .into_result::<FDomainMarker>("write_channel")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<ChannelWriteChannelRequest, ChannelWriteChannelResult>(
            (handle, data, handles),
            0x75a2559b945d5eb5,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ReadChannelStreamingStartResponseFut = fidl::client::QueryResponseFut<
        ChannelReadChannelStreamingStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_channel_streaming_start(
        &self,
        mut handle: &HandleId,
    ) -> Self::ReadChannelStreamingStartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ChannelReadChannelStreamingStartResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3c73e85476a203df,
            >(_buf?)?
            .into_result::<FDomainMarker>("read_channel_streaming_start")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ChannelReadChannelStreamingStartRequest,
            ChannelReadChannelStreamingStartResult,
        >(
            (handle,),
            0x3c73e85476a203df,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ReadChannelStreamingStopResponseFut = fidl::client::QueryResponseFut<
        ChannelReadChannelStreamingStopResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_channel_streaming_stop(
        &self,
        mut handle: &HandleId,
    ) -> Self::ReadChannelStreamingStopResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ChannelReadChannelStreamingStopResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x56f21d6ed68186e0,
            >(_buf?)?
            .into_result::<FDomainMarker>("read_channel_streaming_stop")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ChannelReadChannelStreamingStopRequest,
            ChannelReadChannelStreamingStopResult,
        >(
            (handle,),
            0x56f21d6ed68186e0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type CreateEventResponseFut = fidl::client::QueryResponseFut<
        EventCreateEventResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_event(&self, mut handle: &NewHandleId) -> Self::CreateEventResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EventCreateEventResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7b05b3f262635987,
            >(_buf?)?
            .into_result::<FDomainMarker>("create_event")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<EventCreateEventRequest, EventCreateEventResult>(
            (handle,),
            0x7b05b3f262635987,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type CreateEventPairResponseFut = fidl::client::QueryResponseFut<
        EventPairCreateEventPairResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_event_pair(
        &self,
        mut handles: &[NewHandleId; 2],
    ) -> Self::CreateEventPairResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EventPairCreateEventPairResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7aef61effa65656d,
            >(_buf?)?
            .into_result::<FDomainMarker>("create_event_pair")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            EventPairCreateEventPairRequest,
            EventPairCreateEventPairResult,
        >(
            (handles,),
            0x7aef61effa65656d,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type CreateSocketResponseFut = fidl::client::QueryResponseFut<
        SocketCreateSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_socket(
        &self,
        mut options: SocketType,
        mut handles: &[NewHandleId; 2],
    ) -> Self::CreateSocketResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SocketCreateSocketResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x200bf0ea21932de0,
            >(_buf?)?
            .into_result::<FDomainMarker>("create_socket")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<SocketCreateSocketRequest, SocketCreateSocketResult>(
            (options, handles),
            0x200bf0ea21932de0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SetSocketDispositionResponseFut = fidl::client::QueryResponseFut<
        SocketSetSocketDispositionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_socket_disposition(
        &self,
        mut handle: &HandleId,
        mut disposition: SocketDisposition,
        mut disposition_peer: SocketDisposition,
    ) -> Self::SetSocketDispositionResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SocketSetSocketDispositionResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x60d3c7ccb17f9bdf,
            >(_buf?)?
            .into_result::<FDomainMarker>("set_socket_disposition")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            SocketSetSocketDispositionRequest,
            SocketSetSocketDispositionResult,
        >(
            (handle, disposition, disposition_peer,),
            0x60d3c7ccb17f9bdf,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ReadSocketResponseFut = fidl::client::QueryResponseFut<
        SocketReadSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_socket(
        &self,
        mut handle: &HandleId,
        mut max_bytes: u64,
    ) -> Self::ReadSocketResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SocketReadSocketResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<SocketData, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1da8aabec249c02e,
            >(_buf?)?
            .into_result::<FDomainMarker>("read_socket")?;
            Ok(_response.map(|x| (x.data, x.is_datagram)))
        }
        self.client.send_query_and_decode::<SocketReadSocketRequest, SocketReadSocketResult>(
            (handle, max_bytes),
            0x1da8aabec249c02e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type WriteSocketResponseFut = fidl::client::QueryResponseFut<
        SocketWriteSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_socket(
        &self,
        mut handle: &HandleId,
        mut data: &[u8],
    ) -> Self::WriteSocketResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SocketWriteSocketResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<SocketWriteSocketResponse, WriteSocketError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5b541623cbbbf683,
            >(_buf?)?
            .into_result::<FDomainMarker>("write_socket")?;
            Ok(_response.map(|x| x.wrote))
        }
        self.client.send_query_and_decode::<SocketWriteSocketRequest, SocketWriteSocketResult>(
            (handle, data),
            0x5b541623cbbbf683,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ReadSocketStreamingStartResponseFut = fidl::client::QueryResponseFut<
        SocketReadSocketStreamingStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_socket_streaming_start(
        &self,
        mut handle: &HandleId,
    ) -> Self::ReadSocketStreamingStartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SocketReadSocketStreamingStartResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2a592748d5f33445,
            >(_buf?)?
            .into_result::<FDomainMarker>("read_socket_streaming_start")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            SocketReadSocketStreamingStartRequest,
            SocketReadSocketStreamingStartResult,
        >(
            (handle,),
            0x2a592748d5f33445,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ReadSocketStreamingStopResponseFut = fidl::client::QueryResponseFut<
        SocketReadSocketStreamingStopResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_socket_streaming_stop(
        &self,
        mut handle: &HandleId,
    ) -> Self::ReadSocketStreamingStopResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SocketReadSocketStreamingStopResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x53e5cade5f4d22e7,
            >(_buf?)?
            .into_result::<FDomainMarker>("read_socket_streaming_stop")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            SocketReadSocketStreamingStopRequest,
            SocketReadSocketStreamingStopResult,
        >(
            (handle,),
            0x53e5cade5f4d22e7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type GetNamespaceResponseFut = fidl::client::QueryResponseFut<
        FDomainGetNamespaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_namespace(&self, mut new_handle: &NewHandleId) -> Self::GetNamespaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FDomainGetNamespaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x74f2e74d9f53e11e,
            >(_buf?)?
            .into_result::<FDomainMarker>("get_namespace")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<FDomainGetNamespaceRequest, FDomainGetNamespaceResult>(
            (new_handle,),
            0x74f2e74d9f53e11e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type CloseResponseFut = fidl::client::QueryResponseFut<
        FDomainCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#close(&self, mut handles: &[HandleId]) -> Self::CloseResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FDomainCloseResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5ef8c24362964257,
            >(_buf?)?
            .into_result::<FDomainMarker>("close")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<FDomainCloseRequest, FDomainCloseResult>(
            (handles,),
            0x5ef8c24362964257,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type DuplicateResponseFut = fidl::client::QueryResponseFut<
        FDomainDuplicateResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#duplicate(
        &self,
        mut handle: &HandleId,
        mut new_handle: &NewHandleId,
        mut rights: fidl::Rights,
    ) -> Self::DuplicateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FDomainDuplicateResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7a85b94bd1777ab9,
            >(_buf?)?
            .into_result::<FDomainMarker>("duplicate")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<FDomainDuplicateRequest, FDomainDuplicateResult>(
            (handle, new_handle, rights),
            0x7a85b94bd1777ab9,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ReplaceResponseFut = fidl::client::QueryResponseFut<
        FDomainReplaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#replace(
        &self,
        mut handle: &HandleId,
        mut new_handle: &NewHandleId,
        mut rights: fidl::Rights,
    ) -> Self::ReplaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FDomainReplaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x32fa64625a5bd3be,
            >(_buf?)?
            .into_result::<FDomainMarker>("replace")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<FDomainReplaceRequest, FDomainReplaceResult>(
            (handle, new_handle, rights),
            0x32fa64625a5bd3be,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SignalResponseFut = fidl::client::QueryResponseFut<
        FDomainSignalResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#signal(
        &self,
        mut handle: &HandleId,
        mut set: u32,
        mut clear: u32,
    ) -> Self::SignalResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FDomainSignalResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xe8352fb978996d9,
            >(_buf?)?
            .into_result::<FDomainMarker>("signal")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<FDomainSignalRequest, FDomainSignalResult>(
            (handle, set, clear),
            0xe8352fb978996d9,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SignalPeerResponseFut = fidl::client::QueryResponseFut<
        FDomainSignalPeerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#signal_peer(
        &self,
        mut handle: &HandleId,
        mut set: u32,
        mut clear: u32,
    ) -> Self::SignalPeerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FDomainSignalPeerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7e84ec8ca7eabaf8,
            >(_buf?)?
            .into_result::<FDomainMarker>("signal_peer")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<FDomainSignalPeerRequest, FDomainSignalPeerResult>(
            (handle, set, clear),
            0x7e84ec8ca7eabaf8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type WaitForSignalsResponseFut = fidl::client::QueryResponseFut<
        FDomainWaitForSignalsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#wait_for_signals(
        &self,
        mut handle: &HandleId,
        mut signals: u32,
    ) -> Self::WaitForSignalsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FDomainWaitForSignalsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<FDomainWaitForSignalsResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x8f72d9b4b85c1eb,
            >(_buf?)?
            .into_result::<FDomainMarker>("wait_for_signals")?;
            Ok(_response.map(|x| x.signals))
        }
        self.client
            .send_query_and_decode::<FDomainWaitForSignalsRequest, FDomainWaitForSignalsResult>(
                (handle, signals),
                0x8f72d9b4b85c1eb,
                fidl::encoding::DynamicFlags::FLEXIBLE,
                _decode,
            )
    }

    type GetKoidResponseFut = fidl::client::QueryResponseFut<
        FDomainGetKoidResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_koid(&self, mut handle: &HandleId) -> Self::GetKoidResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FDomainGetKoidResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<FDomainGetKoidResponse, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x437db979a63402c3,
            >(_buf?)?
            .into_result::<FDomainMarker>("get_koid")?;
            Ok(_response.map(|x| x.koid))
        }
        self.client.send_query_and_decode::<FDomainGetKoidRequest, FDomainGetKoidResult>(
            (handle,),
            0x437db979a63402c3,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum FDomainEvent {
    OnChannelStreamingData {
        handle: HandleId,
        channel_sent: ChannelSent,
    },
    OnSocketStreamingData {
        handle: HandleId,
        socket_message: SocketMessage,
    },
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl FDomainEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_channel_streaming_data(self) -> Option<(HandleId, ChannelSent)> {
        if let FDomainEvent::OnChannelStreamingData { handle, channel_sent } = self {
            Some((handle, channel_sent))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_socket_streaming_data(self) -> Option<(HandleId, SocketMessage)> {
        if let FDomainEvent::OnSocketStreamingData { handle, socket_message } = self {
            Some((handle, socket_message))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`FDomainEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<FDomainEvent, 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 {
            0x7d4431805202dfe1 => {
                let mut out = fidl::new_empty!(
                    ChannelOnChannelStreamingDataRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelOnChannelStreamingDataRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((FDomainEvent::OnChannelStreamingData {
                    handle: out.handle,
                    channel_sent: out.channel_sent,
                }))
            }
            0x998b5e66b3c80a2 => {
                let mut out = fidl::new_empty!(
                    SocketOnSocketStreamingDataRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketOnSocketStreamingDataRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((FDomainEvent::OnSocketStreamingData {
                    handle: out.handle,
                    socket_message: out.socket_message,
                }))
            }
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(FDomainEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <FDomainMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for FDomainRequestStream {
    type Protocol = FDomainMarker;
    type ControlHandle = FDomainControlHandle;

    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 {
        FDomainControlHandle { 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 FDomainRequestStream {
    type Item = Result<FDomainRequest, 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 FDomainRequestStream 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 {
                    0x182d38bfe88673b5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ChannelCreateChannelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelCreateChannelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::CreateChannel {
                            handles: req.handles,

                            responder: FDomainCreateChannelResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6ef47bf27bf7d050 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ChannelReadChannelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelReadChannelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::ReadChannel {
                            handle: req.handle,

                            responder: FDomainReadChannelResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x75a2559b945d5eb5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ChannelWriteChannelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelWriteChannelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::WriteChannel {
                            handle: req.handle,
                            data: req.data,
                            handles: req.handles,

                            responder: FDomainWriteChannelResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3c73e85476a203df => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ChannelReadChannelStreamingStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelReadChannelStreamingStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::ReadChannelStreamingStart {
                            handle: req.handle,

                            responder: FDomainReadChannelStreamingStartResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x56f21d6ed68186e0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ChannelReadChannelStreamingStopRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ChannelReadChannelStreamingStopRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::ReadChannelStreamingStop {
                            handle: req.handle,

                            responder: FDomainReadChannelStreamingStopResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7b05b3f262635987 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            EventCreateEventRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EventCreateEventRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::CreateEvent {
                            handle: req.handle,

                            responder: FDomainCreateEventResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7aef61effa65656d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            EventPairCreateEventPairRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EventPairCreateEventPairRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::CreateEventPair {
                            handles: req.handles,

                            responder: FDomainCreateEventPairResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x200bf0ea21932de0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SocketCreateSocketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketCreateSocketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::CreateSocket {
                            options: req.options,
                            handles: req.handles,

                            responder: FDomainCreateSocketResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x60d3c7ccb17f9bdf => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SocketSetSocketDispositionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketSetSocketDispositionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::SetSocketDisposition {
                            handle: req.handle,
                            disposition: req.disposition,
                            disposition_peer: req.disposition_peer,

                            responder: FDomainSetSocketDispositionResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1da8aabec249c02e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SocketReadSocketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketReadSocketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::ReadSocket {
                            handle: req.handle,
                            max_bytes: req.max_bytes,

                            responder: FDomainReadSocketResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5b541623cbbbf683 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SocketWriteSocketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketWriteSocketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::WriteSocket {
                            handle: req.handle,
                            data: req.data,

                            responder: FDomainWriteSocketResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2a592748d5f33445 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SocketReadSocketStreamingStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketReadSocketStreamingStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::ReadSocketStreamingStart {
                            handle: req.handle,

                            responder: FDomainReadSocketStreamingStartResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x53e5cade5f4d22e7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SocketReadSocketStreamingStopRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketReadSocketStreamingStopRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::ReadSocketStreamingStop {
                            handle: req.handle,

                            responder: FDomainReadSocketStreamingStopResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x74f2e74d9f53e11e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FDomainGetNamespaceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FDomainGetNamespaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::GetNamespace {
                            new_handle: req.new_handle,

                            responder: FDomainGetNamespaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5ef8c24362964257 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FDomainCloseRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FDomainCloseRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::Close {
                            handles: req.handles,

                            responder: FDomainCloseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7a85b94bd1777ab9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FDomainDuplicateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FDomainDuplicateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::Duplicate {
                            handle: req.handle,
                            new_handle: req.new_handle,
                            rights: req.rights,

                            responder: FDomainDuplicateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x32fa64625a5bd3be => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FDomainReplaceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FDomainReplaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::Replace {
                            handle: req.handle,
                            new_handle: req.new_handle,
                            rights: req.rights,

                            responder: FDomainReplaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xe8352fb978996d9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FDomainSignalRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FDomainSignalRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::Signal {
                            handle: req.handle,
                            set: req.set,
                            clear: req.clear,

                            responder: FDomainSignalResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7e84ec8ca7eabaf8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FDomainSignalPeerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FDomainSignalPeerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::SignalPeer {
                            handle: req.handle,
                            set: req.set,
                            clear: req.clear,

                            responder: FDomainSignalPeerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x8f72d9b4b85c1eb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FDomainWaitForSignalsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FDomainWaitForSignalsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::WaitForSignals {
                            handle: req.handle,
                            signals: req.signals,

                            responder: FDomainWaitForSignalsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x437db979a63402c3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FDomainGetKoidRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FDomainGetKoidRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FDomainControlHandle { inner: this.inner.clone() };
                        Ok(FDomainRequest::GetKoid {
                            handle: req.handle,

                            responder: FDomainGetKoidResponder {
                                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(FDomainRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: FDomainControlHandle { 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(FDomainRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: FDomainControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <FDomainMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// The FDomain control protocol.
///
/// This protocol is designed to be used over a network or other non-channel
/// transport.
#[derive(Debug)]
pub enum FDomainRequest {
    /// Create a new channel in this FDomain and return both its ends.
    CreateChannel { handles: [NewHandleId; 2], responder: FDomainCreateChannelResponder },
    /// Read a message from a channel. This method will fail if the channel is currently being read
    /// using the streaming read functions.
    ///
    /// Note that this method is not like zx_channel_read in that it will not
    /// return `SHOULD_WAIT` but will instead delay returning until there is data
    /// to return.
    ReadChannel { handle: HandleId, responder: FDomainReadChannelResponder },
    /// Write to a channel. Handles are always consumed.
    WriteChannel {
        handle: HandleId,
        data: Vec<u8>,
        handles: Handles,
        responder: FDomainWriteChannelResponder,
    },
    /// Starts reading from the given channel. Data is returned via the `ChannelStreamingData` event.
    /// That event will occur repeatedly until `ReadChannelStreamingStop` is called for the same handle
    /// or the event indicates the handle is closed.
    ReadChannelStreamingStart {
        handle: HandleId,
        responder: FDomainReadChannelStreamingStartResponder,
    },
    /// Stop asynchronous reading from the given channel.
    ReadChannelStreamingStop {
        handle: HandleId,
        responder: FDomainReadChannelStreamingStopResponder,
    },
    /// Create a new event in this FDomain and return it.
    CreateEvent { handle: NewHandleId, responder: FDomainCreateEventResponder },
    /// Create a new event pair in this FDomain and return both its ends.
    CreateEventPair { handles: [NewHandleId; 2], responder: FDomainCreateEventPairResponder },
    /// Create a new socket in this FDomain and return both its ends.
    CreateSocket {
        options: SocketType,
        handles: [NewHandleId; 2],
        responder: FDomainCreateSocketResponder,
    },
    /// Set the disposition of a given socket.
    SetSocketDisposition {
        handle: HandleId,
        disposition: SocketDisposition,
        disposition_peer: SocketDisposition,
        responder: FDomainSetSocketDispositionResponder,
    },
    /// Read data from a socket. This method will fail if the socket is currently being read
    /// asynchronously.
    ReadSocket { handle: HandleId, max_bytes: u64, responder: FDomainReadSocketResponder },
    /// Write to a socket. This will attempt to write all the data passed, and
    /// will block and retry whenever it is safe (e.g. it should never return
    /// SHOULD_WAIT). The `WriteSocketError` contains a `wrote` parameter to
    /// indicate if some bytes were written successfully before the failure
    /// occurred.
    WriteSocket { handle: HandleId, data: Vec<u8>, responder: FDomainWriteSocketResponder },
    /// Starts reading from the given socket. Data is returned via the `SocketStreamingData` event. That
    /// event will occur repeatedly until `ReadSocketStreamingStop` is called for the same handle or the
    /// event indicates the handle is closed.
    ReadSocketStreamingStart {
        handle: HandleId,
        responder: FDomainReadSocketStreamingStartResponder,
    },
    /// Stop asynchronous reading from the given socket.
    ReadSocketStreamingStop { handle: HandleId, responder: FDomainReadSocketStreamingStopResponder },
    /// Adds a new channel handle to this namespace which points to a
    /// fuchsia.io.Directory. Can be used to "bootstrap" the FDomain.
    GetNamespace { new_handle: NewHandleId, responder: FDomainGetNamespaceResponder },
    /// Close one or more handles.
    Close { handles: Vec<HandleId>, responder: FDomainCloseResponder },
    /// Duplicate a handle.
    Duplicate {
        handle: HandleId,
        new_handle: NewHandleId,
        rights: fidl::Rights,
        responder: FDomainDuplicateResponder,
    },
    /// Close a handle and replace it with a new one with possibly different
    /// rights.
    Replace {
        handle: HandleId,
        new_handle: NewHandleId,
        rights: fidl::Rights,
        responder: FDomainReplaceResponder,
    },
    /// Set or clear signals on a handle.
    Signal { handle: HandleId, set: u32, clear: u32, responder: FDomainSignalResponder },
    /// Set or clear signals on a handle's peer.
    SignalPeer { handle: HandleId, set: u32, clear: u32, responder: FDomainSignalPeerResponder },
    /// Wait for signals from the given handle. Reply will be returned when one
    /// of the given signals is asserted.
    WaitForSignals { handle: HandleId, signals: u32, responder: FDomainWaitForSignalsResponder },
    /// Return the kernel object ID (koid) of the handle.
    GetKoid { handle: HandleId, responder: FDomainGetKoidResponder },
    /// 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: FDomainControlHandle,
        method_type: fidl::MethodType,
    },
}

impl FDomainRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_channel(self) -> Option<([NewHandleId; 2], FDomainCreateChannelResponder)> {
        if let FDomainRequest::CreateChannel { handles, responder } = self {
            Some((handles, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_channel(self) -> Option<(HandleId, FDomainReadChannelResponder)> {
        if let FDomainRequest::ReadChannel { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_channel(
        self,
    ) -> Option<(HandleId, Vec<u8>, Handles, FDomainWriteChannelResponder)> {
        if let FDomainRequest::WriteChannel { handle, data, handles, responder } = self {
            Some((handle, data, handles, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_channel_streaming_start(
        self,
    ) -> Option<(HandleId, FDomainReadChannelStreamingStartResponder)> {
        if let FDomainRequest::ReadChannelStreamingStart { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_channel_streaming_stop(
        self,
    ) -> Option<(HandleId, FDomainReadChannelStreamingStopResponder)> {
        if let FDomainRequest::ReadChannelStreamingStop { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_event(self) -> Option<(NewHandleId, FDomainCreateEventResponder)> {
        if let FDomainRequest::CreateEvent { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_event_pair(
        self,
    ) -> Option<([NewHandleId; 2], FDomainCreateEventPairResponder)> {
        if let FDomainRequest::CreateEventPair { handles, responder } = self {
            Some((handles, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_socket(
        self,
    ) -> Option<(SocketType, [NewHandleId; 2], FDomainCreateSocketResponder)> {
        if let FDomainRequest::CreateSocket { options, handles, responder } = self {
            Some((options, handles, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_socket_disposition(
        self,
    ) -> Option<(
        HandleId,
        SocketDisposition,
        SocketDisposition,
        FDomainSetSocketDispositionResponder,
    )> {
        if let FDomainRequest::SetSocketDisposition {
            handle,
            disposition,
            disposition_peer,
            responder,
        } = self
        {
            Some((handle, disposition, disposition_peer, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_socket(self) -> Option<(HandleId, u64, FDomainReadSocketResponder)> {
        if let FDomainRequest::ReadSocket { handle, max_bytes, responder } = self {
            Some((handle, max_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_socket(self) -> Option<(HandleId, Vec<u8>, FDomainWriteSocketResponder)> {
        if let FDomainRequest::WriteSocket { handle, data, responder } = self {
            Some((handle, data, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_socket_streaming_start(
        self,
    ) -> Option<(HandleId, FDomainReadSocketStreamingStartResponder)> {
        if let FDomainRequest::ReadSocketStreamingStart { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_socket_streaming_stop(
        self,
    ) -> Option<(HandleId, FDomainReadSocketStreamingStopResponder)> {
        if let FDomainRequest::ReadSocketStreamingStop { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_namespace(self) -> Option<(NewHandleId, FDomainGetNamespaceResponder)> {
        if let FDomainRequest::GetNamespace { new_handle, responder } = self {
            Some((new_handle, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(Vec<HandleId>, FDomainCloseResponder)> {
        if let FDomainRequest::Close { handles, responder } = self {
            Some((handles, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_duplicate(
        self,
    ) -> Option<(HandleId, NewHandleId, fidl::Rights, FDomainDuplicateResponder)> {
        if let FDomainRequest::Duplicate { handle, new_handle, rights, responder } = self {
            Some((handle, new_handle, rights, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_replace(
        self,
    ) -> Option<(HandleId, NewHandleId, fidl::Rights, FDomainReplaceResponder)> {
        if let FDomainRequest::Replace { handle, new_handle, rights, responder } = self {
            Some((handle, new_handle, rights, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_signal(self) -> Option<(HandleId, u32, u32, FDomainSignalResponder)> {
        if let FDomainRequest::Signal { handle, set, clear, responder } = self {
            Some((handle, set, clear, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_signal_peer(self) -> Option<(HandleId, u32, u32, FDomainSignalPeerResponder)> {
        if let FDomainRequest::SignalPeer { handle, set, clear, responder } = self {
            Some((handle, set, clear, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_wait_for_signals(self) -> Option<(HandleId, u32, FDomainWaitForSignalsResponder)> {
        if let FDomainRequest::WaitForSignals { handle, signals, responder } = self {
            Some((handle, signals, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_koid(self) -> Option<(HandleId, FDomainGetKoidResponder)> {
        if let FDomainRequest::GetKoid { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            FDomainRequest::CreateChannel { .. } => "create_channel",
            FDomainRequest::ReadChannel { .. } => "read_channel",
            FDomainRequest::WriteChannel { .. } => "write_channel",
            FDomainRequest::ReadChannelStreamingStart { .. } => "read_channel_streaming_start",
            FDomainRequest::ReadChannelStreamingStop { .. } => "read_channel_streaming_stop",
            FDomainRequest::CreateEvent { .. } => "create_event",
            FDomainRequest::CreateEventPair { .. } => "create_event_pair",
            FDomainRequest::CreateSocket { .. } => "create_socket",
            FDomainRequest::SetSocketDisposition { .. } => "set_socket_disposition",
            FDomainRequest::ReadSocket { .. } => "read_socket",
            FDomainRequest::WriteSocket { .. } => "write_socket",
            FDomainRequest::ReadSocketStreamingStart { .. } => "read_socket_streaming_start",
            FDomainRequest::ReadSocketStreamingStop { .. } => "read_socket_streaming_stop",
            FDomainRequest::GetNamespace { .. } => "get_namespace",
            FDomainRequest::Close { .. } => "close",
            FDomainRequest::Duplicate { .. } => "duplicate",
            FDomainRequest::Replace { .. } => "replace",
            FDomainRequest::Signal { .. } => "signal",
            FDomainRequest::SignalPeer { .. } => "signal_peer",
            FDomainRequest::WaitForSignals { .. } => "wait_for_signals",
            FDomainRequest::GetKoid { .. } => "get_koid",
            FDomainRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            FDomainRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

impl fidl::endpoints::ControlHandle for FDomainControlHandle {
    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 FDomainControlHandle {
    pub fn send_on_channel_streaming_data(
        &self,
        mut handle: &HandleId,
        mut channel_sent: &ChannelSent,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<ChannelOnChannelStreamingDataRequest>(
            (handle, channel_sent),
            0,
            0x7d4431805202dfe1,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    pub fn send_on_socket_streaming_data(
        &self,
        mut handle: &HandleId,
        mut socket_message: &SocketMessage,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<SocketOnSocketStreamingDataRequest>(
            (handle, socket_message),
            0,
            0x998b5e66b3c80a2,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &FDomainControlHandle {
        &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 FDomainCreateChannelResponder {
    /// 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,
            0x182d38bfe88673b5,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut result: Result<(&[u8], &[HandleInfo]), &Error>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<ChannelMessage, Error>>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x6ef47bf27bf7d050,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

    fn control_handle(&self) -> &FDomainControlHandle {
        &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 FDomainReadChannelStreamingStartResponder {
    /// 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,
            0x3c73e85476a203df,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &FDomainControlHandle {
        &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 FDomainReadChannelStreamingStopResponder {
    /// 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,
            0x56f21d6ed68186e0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &FDomainControlHandle {
        &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 FDomainCreateEventResponder {
    /// 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,
            0x7b05b3f262635987,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &FDomainControlHandle {
        &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 FDomainCreateEventPairResponder {
    /// 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,
            0x7aef61effa65656d,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &FDomainControlHandle {
        &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 FDomainCreateSocketResponder {
    /// 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,
            0x200bf0ea21932de0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &FDomainControlHandle {
        &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 FDomainSetSocketDispositionResponder {
    /// 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,
            0x60d3c7ccb17f9bdf,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<(&[u8], bool), &Error>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<SocketData, Error>>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x1da8aabec249c02e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<u64, &WriteSocketError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            SocketWriteSocketResponse,
            WriteSocketError,
        >>(
            fidl::encoding::FlexibleResult::new(result.map(|wrote| (wrote,))),
            self.tx_id,
            0x5b541623cbbbf683,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &FDomainControlHandle {
        &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 FDomainReadSocketStreamingStartResponder {
    /// 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,
            0x2a592748d5f33445,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &FDomainControlHandle {
        &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 FDomainReadSocketStreamingStopResponder {
    /// 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,
            0x53e5cade5f4d22e7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &FDomainControlHandle {
        &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 FDomainGetNamespaceResponder {
    /// 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,
            0x74f2e74d9f53e11e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &FDomainControlHandle {
        &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 FDomainCloseResponder {
    /// 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,
            0x5ef8c24362964257,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &FDomainControlHandle {
        &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 FDomainDuplicateResponder {
    /// 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,
            0x7a85b94bd1777ab9,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &FDomainControlHandle {
        &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 FDomainReplaceResponder {
    /// 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,
            0x32fa64625a5bd3be,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &FDomainControlHandle {
        &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 FDomainSignalResponder {
    /// 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,
            0xe8352fb978996d9,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &FDomainControlHandle {
        &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 FDomainSignalPeerResponder {
    /// 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,
            0x7e84ec8ca7eabaf8,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for SocketMarker {
    type Proxy = SocketProxy;
    type RequestStream = SocketRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SocketSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Socket";
}
pub type SocketCreateSocketResult = Result<(), Error>;
pub type SocketSetSocketDispositionResult = Result<(), Error>;
pub type SocketReadSocketResult = Result<(Vec<u8>, bool), Error>;
pub type SocketWriteSocketResult = Result<u64, WriteSocketError>;
pub type SocketReadSocketStreamingStartResult = Result<(), Error>;
pub type SocketReadSocketStreamingStopResult = Result<(), Error>;

pub trait SocketProxyInterface: Send + Sync {
    type CreateSocketResponseFut: std::future::Future<Output = Result<SocketCreateSocketResult, fidl::Error>>
        + Send;
    fn r#create_socket(
        &self,
        options: SocketType,
        handles: &[NewHandleId; 2],
    ) -> Self::CreateSocketResponseFut;
    type SetSocketDispositionResponseFut: std::future::Future<Output = Result<SocketSetSocketDispositionResult, fidl::Error>>
        + Send;
    fn r#set_socket_disposition(
        &self,
        handle: &HandleId,
        disposition: SocketDisposition,
        disposition_peer: SocketDisposition,
    ) -> Self::SetSocketDispositionResponseFut;
    type ReadSocketResponseFut: std::future::Future<Output = Result<SocketReadSocketResult, fidl::Error>>
        + Send;
    fn r#read_socket(&self, handle: &HandleId, max_bytes: u64) -> Self::ReadSocketResponseFut;
    type WriteSocketResponseFut: std::future::Future<Output = Result<SocketWriteSocketResult, fidl::Error>>
        + Send;
    fn r#write_socket(&self, handle: &HandleId, data: &[u8]) -> Self::WriteSocketResponseFut;
    type ReadSocketStreamingStartResponseFut: std::future::Future<Output = Result<SocketReadSocketStreamingStartResult, fidl::Error>>
        + Send;
    fn r#read_socket_streaming_start(
        &self,
        handle: &HandleId,
    ) -> Self::ReadSocketStreamingStartResponseFut;
    type ReadSocketStreamingStopResponseFut: std::future::Future<Output = Result<SocketReadSocketStreamingStopResult, fidl::Error>>
        + Send;
    fn r#read_socket_streaming_stop(
        &self,
        handle: &HandleId,
    ) -> Self::ReadSocketStreamingStopResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SocketSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SocketSynchronousProxy {
    type Proxy = SocketProxy;
    type Protocol = SocketMarker;

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

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

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

    /// Create a new socket in this FDomain and return both its ends.
    pub fn r#create_socket(
        &self,
        mut options: SocketType,
        mut handles: &[NewHandleId; 2],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SocketCreateSocketResult, fidl::Error> {
        let _response = self.client.send_query::<
            SocketCreateSocketRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            SocketMarker,
        >(
            (options, handles,),
            0x200bf0ea21932de0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SocketMarker>("create_socket")?;
        Ok(_response.map(|x| x))
    }

    /// Set the disposition of a given socket.
    pub fn r#set_socket_disposition(
        &self,
        mut handle: &HandleId,
        mut disposition: SocketDisposition,
        mut disposition_peer: SocketDisposition,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SocketSetSocketDispositionResult, fidl::Error> {
        let _response = self.client.send_query::<
            SocketSetSocketDispositionRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            SocketMarker,
        >(
            (handle, disposition, disposition_peer,),
            0x60d3c7ccb17f9bdf,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SocketMarker>("set_socket_disposition")?;
        Ok(_response.map(|x| x))
    }

    /// Read data from a socket. This method will fail if the socket is currently being read
    /// asynchronously.
    pub fn r#read_socket(
        &self,
        mut handle: &HandleId,
        mut max_bytes: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SocketReadSocketResult, fidl::Error> {
        let _response = self.client.send_query::<
            SocketReadSocketRequest,
            fidl::encoding::FlexibleResultType<SocketData, Error>,
            SocketMarker,
        >(
            (handle, max_bytes,),
            0x1da8aabec249c02e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SocketMarker>("read_socket")?;
        Ok(_response.map(|x| (x.data, x.is_datagram)))
    }

    /// Write to a socket. This will attempt to write all the data passed, and
    /// will block and retry whenever it is safe (e.g. it should never return
    /// SHOULD_WAIT). The `WriteSocketError` contains a `wrote` parameter to
    /// indicate if some bytes were written successfully before the failure
    /// occurred.
    pub fn r#write_socket(
        &self,
        mut handle: &HandleId,
        mut data: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SocketWriteSocketResult, fidl::Error> {
        let _response = self.client.send_query::<
            SocketWriteSocketRequest,
            fidl::encoding::FlexibleResultType<SocketWriteSocketResponse, WriteSocketError>,
            SocketMarker,
        >(
            (handle, data,),
            0x5b541623cbbbf683,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SocketMarker>("write_socket")?;
        Ok(_response.map(|x| x.wrote))
    }

    /// Starts reading from the given socket. Data is returned via the `SocketStreamingData` event. That
    /// event will occur repeatedly until `ReadSocketStreamingStop` is called for the same handle or the
    /// event indicates the handle is closed.
    pub fn r#read_socket_streaming_start(
        &self,
        mut handle: &HandleId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SocketReadSocketStreamingStartResult, fidl::Error> {
        let _response = self.client.send_query::<
            SocketReadSocketStreamingStartRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            SocketMarker,
        >(
            (handle,),
            0x2a592748d5f33445,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SocketMarker>("read_socket_streaming_start")?;
        Ok(_response.map(|x| x))
    }

    /// Stop asynchronous reading from the given socket.
    pub fn r#read_socket_streaming_stop(
        &self,
        mut handle: &HandleId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SocketReadSocketStreamingStopResult, fidl::Error> {
        let _response = self.client.send_query::<
            SocketReadSocketStreamingStopRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
            SocketMarker,
        >(
            (handle,),
            0x53e5cade5f4d22e7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<SocketMarker>("read_socket_streaming_stop")?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for SocketProxy {
    type Protocol = SocketMarker;

    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 SocketProxy {
    /// Create a new Proxy for fuchsia.fdomain/Socket.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <SocketMarker 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) -> SocketEventStream {
        SocketEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Create a new socket in this FDomain and return both its ends.
    pub fn r#create_socket(
        &self,
        mut options: SocketType,
        mut handles: &[NewHandleId; 2],
    ) -> fidl::client::QueryResponseFut<
        SocketCreateSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SocketProxyInterface::r#create_socket(self, options, handles)
    }

    /// Set the disposition of a given socket.
    pub fn r#set_socket_disposition(
        &self,
        mut handle: &HandleId,
        mut disposition: SocketDisposition,
        mut disposition_peer: SocketDisposition,
    ) -> fidl::client::QueryResponseFut<
        SocketSetSocketDispositionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SocketProxyInterface::r#set_socket_disposition(self, handle, disposition, disposition_peer)
    }

    /// Read data from a socket. This method will fail if the socket is currently being read
    /// asynchronously.
    pub fn r#read_socket(
        &self,
        mut handle: &HandleId,
        mut max_bytes: u64,
    ) -> fidl::client::QueryResponseFut<
        SocketReadSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SocketProxyInterface::r#read_socket(self, handle, max_bytes)
    }

    /// Write to a socket. This will attempt to write all the data passed, and
    /// will block and retry whenever it is safe (e.g. it should never return
    /// SHOULD_WAIT). The `WriteSocketError` contains a `wrote` parameter to
    /// indicate if some bytes were written successfully before the failure
    /// occurred.
    pub fn r#write_socket(
        &self,
        mut handle: &HandleId,
        mut data: &[u8],
    ) -> fidl::client::QueryResponseFut<
        SocketWriteSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SocketProxyInterface::r#write_socket(self, handle, data)
    }

    /// Starts reading from the given socket. Data is returned via the `SocketStreamingData` event. That
    /// event will occur repeatedly until `ReadSocketStreamingStop` is called for the same handle or the
    /// event indicates the handle is closed.
    pub fn r#read_socket_streaming_start(
        &self,
        mut handle: &HandleId,
    ) -> fidl::client::QueryResponseFut<
        SocketReadSocketStreamingStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SocketProxyInterface::r#read_socket_streaming_start(self, handle)
    }

    /// Stop asynchronous reading from the given socket.
    pub fn r#read_socket_streaming_stop(
        &self,
        mut handle: &HandleId,
    ) -> fidl::client::QueryResponseFut<
        SocketReadSocketStreamingStopResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SocketProxyInterface::r#read_socket_streaming_stop(self, handle)
    }
}

impl SocketProxyInterface for SocketProxy {
    type CreateSocketResponseFut = fidl::client::QueryResponseFut<
        SocketCreateSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_socket(
        &self,
        mut options: SocketType,
        mut handles: &[NewHandleId; 2],
    ) -> Self::CreateSocketResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SocketCreateSocketResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x200bf0ea21932de0,
            >(_buf?)?
            .into_result::<SocketMarker>("create_socket")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<SocketCreateSocketRequest, SocketCreateSocketResult>(
            (options, handles),
            0x200bf0ea21932de0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type SetSocketDispositionResponseFut = fidl::client::QueryResponseFut<
        SocketSetSocketDispositionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_socket_disposition(
        &self,
        mut handle: &HandleId,
        mut disposition: SocketDisposition,
        mut disposition_peer: SocketDisposition,
    ) -> Self::SetSocketDispositionResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SocketSetSocketDispositionResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x60d3c7ccb17f9bdf,
            >(_buf?)?
            .into_result::<SocketMarker>("set_socket_disposition")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            SocketSetSocketDispositionRequest,
            SocketSetSocketDispositionResult,
        >(
            (handle, disposition, disposition_peer,),
            0x60d3c7ccb17f9bdf,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ReadSocketResponseFut = fidl::client::QueryResponseFut<
        SocketReadSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_socket(
        &self,
        mut handle: &HandleId,
        mut max_bytes: u64,
    ) -> Self::ReadSocketResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SocketReadSocketResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<SocketData, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1da8aabec249c02e,
            >(_buf?)?
            .into_result::<SocketMarker>("read_socket")?;
            Ok(_response.map(|x| (x.data, x.is_datagram)))
        }
        self.client.send_query_and_decode::<SocketReadSocketRequest, SocketReadSocketResult>(
            (handle, max_bytes),
            0x1da8aabec249c02e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type WriteSocketResponseFut = fidl::client::QueryResponseFut<
        SocketWriteSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#write_socket(
        &self,
        mut handle: &HandleId,
        mut data: &[u8],
    ) -> Self::WriteSocketResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SocketWriteSocketResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<SocketWriteSocketResponse, WriteSocketError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5b541623cbbbf683,
            >(_buf?)?
            .into_result::<SocketMarker>("write_socket")?;
            Ok(_response.map(|x| x.wrote))
        }
        self.client.send_query_and_decode::<SocketWriteSocketRequest, SocketWriteSocketResult>(
            (handle, data),
            0x5b541623cbbbf683,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ReadSocketStreamingStartResponseFut = fidl::client::QueryResponseFut<
        SocketReadSocketStreamingStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_socket_streaming_start(
        &self,
        mut handle: &HandleId,
    ) -> Self::ReadSocketStreamingStartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SocketReadSocketStreamingStartResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2a592748d5f33445,
            >(_buf?)?
            .into_result::<SocketMarker>("read_socket_streaming_start")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            SocketReadSocketStreamingStartRequest,
            SocketReadSocketStreamingStartResult,
        >(
            (handle,),
            0x2a592748d5f33445,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type ReadSocketStreamingStopResponseFut = fidl::client::QueryResponseFut<
        SocketReadSocketStreamingStopResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#read_socket_streaming_stop(
        &self,
        mut handle: &HandleId,
    ) -> Self::ReadSocketStreamingStopResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SocketReadSocketStreamingStopResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, Error>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x53e5cade5f4d22e7,
            >(_buf?)?
            .into_result::<SocketMarker>("read_socket_streaming_stop")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            SocketReadSocketStreamingStopRequest,
            SocketReadSocketStreamingStopResult,
        >(
            (handle,),
            0x53e5cade5f4d22e7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum SocketEvent {
    OnSocketStreamingData {
        handle: HandleId,
        socket_message: SocketMessage,
    },
    #[non_exhaustive]
    _UnknownEvent {
        /// Ordinal of the event that was sent.
        ordinal: u64,
    },
}

impl SocketEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_socket_streaming_data(self) -> Option<(HandleId, SocketMessage)> {
        if let SocketEvent::OnSocketStreamingData { handle, socket_message } = self {
            Some((handle, socket_message))
        } else {
            None
        }
    }

    /// Decodes a message buffer as a [`SocketEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<SocketEvent, 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 {
            0x998b5e66b3c80a2 => {
                let mut out = fidl::new_empty!(
                    SocketOnSocketStreamingDataRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketOnSocketStreamingDataRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((SocketEvent::OnSocketStreamingData {
                    handle: out.handle,
                    socket_message: out.socket_message,
                }))
            }
            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
                Ok(SocketEvent::_UnknownEvent { ordinal: tx_header.ordinal })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <SocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for SocketRequestStream {
    type Protocol = SocketMarker;
    type ControlHandle = SocketControlHandle;

    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 {
        SocketControlHandle { 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 SocketRequestStream {
    type Item = Result<SocketRequest, 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 SocketRequestStream 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 {
                    0x200bf0ea21932de0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SocketCreateSocketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketCreateSocketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
                        Ok(SocketRequest::CreateSocket {
                            options: req.options,
                            handles: req.handles,

                            responder: SocketCreateSocketResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x60d3c7ccb17f9bdf => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SocketSetSocketDispositionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketSetSocketDispositionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
                        Ok(SocketRequest::SetSocketDisposition {
                            handle: req.handle,
                            disposition: req.disposition,
                            disposition_peer: req.disposition_peer,

                            responder: SocketSetSocketDispositionResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1da8aabec249c02e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SocketReadSocketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketReadSocketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
                        Ok(SocketRequest::ReadSocket {
                            handle: req.handle,
                            max_bytes: req.max_bytes,

                            responder: SocketReadSocketResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5b541623cbbbf683 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SocketWriteSocketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketWriteSocketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
                        Ok(SocketRequest::WriteSocket {
                            handle: req.handle,
                            data: req.data,

                            responder: SocketWriteSocketResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2a592748d5f33445 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SocketReadSocketStreamingStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketReadSocketStreamingStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
                        Ok(SocketRequest::ReadSocketStreamingStart {
                            handle: req.handle,

                            responder: SocketReadSocketStreamingStartResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x53e5cade5f4d22e7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            SocketReadSocketStreamingStopRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SocketReadSocketStreamingStopRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = SocketControlHandle { inner: this.inner.clone() };
                        Ok(SocketRequest::ReadSocketStreamingStop {
                            handle: req.handle,

                            responder: SocketReadSocketStreamingStopResponder {
                                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(SocketRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: SocketControlHandle { 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(SocketRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: SocketControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <SocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// FDomain operations on sockets
#[derive(Debug)]
pub enum SocketRequest {
    /// Create a new socket in this FDomain and return both its ends.
    CreateSocket {
        options: SocketType,
        handles: [NewHandleId; 2],
        responder: SocketCreateSocketResponder,
    },
    /// Set the disposition of a given socket.
    SetSocketDisposition {
        handle: HandleId,
        disposition: SocketDisposition,
        disposition_peer: SocketDisposition,
        responder: SocketSetSocketDispositionResponder,
    },
    /// Read data from a socket. This method will fail if the socket is currently being read
    /// asynchronously.
    ReadSocket { handle: HandleId, max_bytes: u64, responder: SocketReadSocketResponder },
    /// Write to a socket. This will attempt to write all the data passed, and
    /// will block and retry whenever it is safe (e.g. it should never return
    /// SHOULD_WAIT). The `WriteSocketError` contains a `wrote` parameter to
    /// indicate if some bytes were written successfully before the failure
    /// occurred.
    WriteSocket { handle: HandleId, data: Vec<u8>, responder: SocketWriteSocketResponder },
    /// Starts reading from the given socket. Data is returned via the `SocketStreamingData` event. That
    /// event will occur repeatedly until `ReadSocketStreamingStop` is called for the same handle or the
    /// event indicates the handle is closed.
    ReadSocketStreamingStart {
        handle: HandleId,
        responder: SocketReadSocketStreamingStartResponder,
    },
    /// Stop asynchronous reading from the given socket.
    ReadSocketStreamingStop { handle: HandleId, responder: SocketReadSocketStreamingStopResponder },
    /// 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: SocketControlHandle,
        method_type: fidl::MethodType,
    },
}

impl SocketRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_socket(
        self,
    ) -> Option<(SocketType, [NewHandleId; 2], SocketCreateSocketResponder)> {
        if let SocketRequest::CreateSocket { options, handles, responder } = self {
            Some((options, handles, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_socket_disposition(
        self,
    ) -> Option<(HandleId, SocketDisposition, SocketDisposition, SocketSetSocketDispositionResponder)>
    {
        if let SocketRequest::SetSocketDisposition {
            handle,
            disposition,
            disposition_peer,
            responder,
        } = self
        {
            Some((handle, disposition, disposition_peer, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_socket(self) -> Option<(HandleId, u64, SocketReadSocketResponder)> {
        if let SocketRequest::ReadSocket { handle, max_bytes, responder } = self {
            Some((handle, max_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_write_socket(self) -> Option<(HandleId, Vec<u8>, SocketWriteSocketResponder)> {
        if let SocketRequest::WriteSocket { handle, data, responder } = self {
            Some((handle, data, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_socket_streaming_start(
        self,
    ) -> Option<(HandleId, SocketReadSocketStreamingStartResponder)> {
        if let SocketRequest::ReadSocketStreamingStart { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_read_socket_streaming_stop(
        self,
    ) -> Option<(HandleId, SocketReadSocketStreamingStopResponder)> {
        if let SocketRequest::ReadSocketStreamingStop { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            SocketRequest::CreateSocket { .. } => "create_socket",
            SocketRequest::SetSocketDisposition { .. } => "set_socket_disposition",
            SocketRequest::ReadSocket { .. } => "read_socket",
            SocketRequest::WriteSocket { .. } => "write_socket",
            SocketRequest::ReadSocketStreamingStart { .. } => "read_socket_streaming_start",
            SocketRequest::ReadSocketStreamingStop { .. } => "read_socket_streaming_stop",
            SocketRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            SocketRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

impl fidl::endpoints::ControlHandle for SocketControlHandle {
    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 SocketControlHandle {
    pub fn send_on_socket_streaming_data(
        &self,
        mut handle: &HandleId,
        mut socket_message: &SocketMessage,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<SocketOnSocketStreamingDataRequest>(
            (handle, socket_message),
            0,
            0x998b5e66b3c80a2,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &SocketControlHandle {
        &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 SocketCreateSocketResponder {
    /// 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,
            0x200bf0ea21932de0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &SocketControlHandle {
        &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 SocketSetSocketDispositionResponder {
    /// 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,
            0x60d3c7ccb17f9bdf,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<(&[u8], bool), &Error>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<SocketData, Error>>(
            fidl::encoding::FlexibleResult::new(result),
            self.tx_id,
            0x1da8aabec249c02e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(&self, mut result: Result<u64, &WriteSocketError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
            SocketWriteSocketResponse,
            WriteSocketError,
        >>(
            fidl::encoding::FlexibleResult::new(result.map(|wrote| (wrote,))),
            self.tx_id,
            0x5b541623cbbbf683,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &SocketControlHandle {
        &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 SocketReadSocketStreamingStartResponder {
    /// 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,
            0x2a592748d5f33445,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

    fn control_handle(&self) -> &SocketControlHandle {
        &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 SocketReadSocketStreamingStopResponder {
    /// 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,
            0x53e5cade5f4d22e7,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

mod internal {
    use super::*;
}