fidl_fidl_serversuite/

fidl_fidl_serversuite.rs

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

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

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ClosedTargetCreateNHandleVectorRequest {
    pub n: u32,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ClosedTargetCreateNHandleVectorResponse {
    pub vec: Vec<fidl::Event>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ClosedTargetEchoAsTransferableSignalableEventRequest {
    pub handle: fidl::NullableHandle,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ClosedTargetEchoAsTransferableSignalableEventResponse {
    pub handle: fidl::Event,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ClosedTargetGetHandleRightsRequest {
    pub handle: fidl::NullableHandle,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ClosedTargetGetSignalableEventRightsRequest {
    pub handle: fidl::Event,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ClosedTargetHandleVectorSizeRequest {
    pub vec: Vec<fidl::Event>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerStartRequest {
    pub test: Test,
    pub any_target: AnyTarget,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum AnyTarget {
    Closed(fidl::endpoints::ServerEnd<ClosedTargetMarker>),
    Ajar(fidl::endpoints::ServerEnd<AjarTargetMarker>),
    Open(fidl::endpoints::ServerEnd<OpenTargetMarker>),
}

impl AnyTarget {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Closed(_) => 1,
            Self::Ajar(_) => 2,
            Self::Open(_) => 3,
        }
    }
}

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

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

impl fidl::endpoints::ProtocolMarker for AjarTargetMarker {
    type Proxy = AjarTargetProxy;
    type RequestStream = AjarTargetRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AjarTargetSynchronousProxy;

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AjarTargetSynchronousProxy {
    type Proxy = AjarTargetProxy;
    type Protocol = AjarTargetMarker;

    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 AjarTargetSynchronousProxy {
    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<AjarTargetEvent, fidl::Error> {
        AjarTargetEvent::decode(self.client.wait_for_event::<AjarTargetMarker>(deadline)?)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AjarTargetProxy {
    type Protocol = AjarTargetMarker;

    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 AjarTargetProxy {
    /// Create a new Proxy for fidl.serversuite/AjarTarget.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <AjarTargetMarker 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) -> AjarTargetEventStream {
        AjarTargetEventStream { event_receiver: self.client.take_event_receiver() }
    }
}

impl AjarTargetProxyInterface for AjarTargetProxy {}

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

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

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

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

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

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

/// A Stream of incoming requests for fidl.serversuite/AjarTarget.
pub struct AjarTargetRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for AjarTargetRequestStream {
    type Protocol = AjarTargetMarker;
    type ControlHandle = AjarTargetControlHandle;

    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 {
        AjarTargetControlHandle { 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 AjarTargetRequestStream {
    type Item = Result<AjarTargetRequest, 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 AjarTargetRequestStream 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 {
                    _ if header.tx_id == 0
                        && header
                            .dynamic_flags()
                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
                    {
                        Ok(AjarTargetRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: AjarTargetControlHandle { inner: this.inner.clone() },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <AjarTargetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum AjarTargetRequest {
    /// 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: AjarTargetControlHandle,
    },
}

impl AjarTargetRequest {
    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            AjarTargetRequest::_UnknownMethod { .. } => "unknown one-way method",
        }
    }
}

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

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

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

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

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

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

impl AjarTargetControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for ClosedTargetMarker {
    type Proxy = ClosedTargetProxy;
    type RequestStream = ClosedTargetRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ClosedTargetSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) ClosedTarget";
}
pub type ClosedTargetTwoWayResultResult = Result<String, u32>;

pub trait ClosedTargetProxyInterface: Send + Sync {
    fn r#one_way_no_payload(&self) -> Result<(), fidl::Error>;
    type TwoWayNoPayloadResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#two_way_no_payload(&self) -> Self::TwoWayNoPayloadResponseFut;
    type TwoWayStructPayloadResponseFut: std::future::Future<Output = Result<i8, fidl::Error>>
        + Send;
    fn r#two_way_struct_payload(&self, v: i8) -> Self::TwoWayStructPayloadResponseFut;
    type TwoWayTablePayloadResponseFut: std::future::Future<Output = Result<ClosedTargetTwoWayTablePayloadResponse, fidl::Error>>
        + Send;
    fn r#two_way_table_payload(
        &self,
        payload: &ClosedTargetTwoWayTablePayloadRequest,
    ) -> Self::TwoWayTablePayloadResponseFut;
    type TwoWayUnionPayloadResponseFut: std::future::Future<Output = Result<ClosedTargetTwoWayUnionPayloadResponse, fidl::Error>>
        + Send;
    fn r#two_way_union_payload(
        &self,
        payload: &ClosedTargetTwoWayUnionPayloadRequest,
    ) -> Self::TwoWayUnionPayloadResponseFut;
    type TwoWayResultResponseFut: std::future::Future<Output = Result<ClosedTargetTwoWayResultResult, fidl::Error>>
        + Send;
    fn r#two_way_result(
        &self,
        payload: &ClosedTargetTwoWayResultRequest,
    ) -> Self::TwoWayResultResponseFut;
    type GetHandleRightsResponseFut: std::future::Future<Output = Result<fidl::Rights, fidl::Error>>
        + Send;
    fn r#get_handle_rights(&self, handle: fidl::NullableHandle)
    -> Self::GetHandleRightsResponseFut;
    type GetSignalableEventRightsResponseFut: std::future::Future<Output = Result<fidl::Rights, fidl::Error>>
        + Send;
    fn r#get_signalable_event_rights(
        &self,
        handle: fidl::Event,
    ) -> Self::GetSignalableEventRightsResponseFut;
    type EchoAsTransferableSignalableEventResponseFut: std::future::Future<Output = Result<fidl::Event, fidl::Error>>
        + Send;
    fn r#echo_as_transferable_signalable_event(
        &self,
        handle: fidl::NullableHandle,
    ) -> Self::EchoAsTransferableSignalableEventResponseFut;
    type ByteVectorSizeResponseFut: std::future::Future<Output = Result<u32, fidl::Error>> + Send;
    fn r#byte_vector_size(&self, vec: &[u8]) -> Self::ByteVectorSizeResponseFut;
    type HandleVectorSizeResponseFut: std::future::Future<Output = Result<u32, fidl::Error>> + Send;
    fn r#handle_vector_size(&self, vec: Vec<fidl::Event>) -> Self::HandleVectorSizeResponseFut;
    type CreateNByteVectorResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>>
        + Send;
    fn r#create_n_byte_vector(&self, n: u32) -> Self::CreateNByteVectorResponseFut;
    type CreateNHandleVectorResponseFut: std::future::Future<Output = Result<Vec<fidl::Event>, fidl::Error>>
        + Send;
    fn r#create_n_handle_vector(&self, n: u32) -> Self::CreateNHandleVectorResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ClosedTargetSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ClosedTargetSynchronousProxy {
    type Proxy = ClosedTargetProxy;
    type Protocol = ClosedTargetMarker;

    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 ClosedTargetSynchronousProxy {
    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<ClosedTargetEvent, fidl::Error> {
        ClosedTargetEvent::decode(self.client.wait_for_event::<ClosedTargetMarker>(deadline)?)
    }

    pub fn r#one_way_no_payload(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x66bd5fe1d4c019e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#two_way_no_payload(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::EmptyPayload,
            ClosedTargetMarker,
        >(
            (),
            0x5bda1d1c46a5ae5f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    pub fn r#two_way_struct_payload(
        &self,
        mut v: i8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i8, fidl::Error> {
        let _response = self.client.send_query::<
            ClosedTargetTwoWayStructPayloadRequest,
            ClosedTargetTwoWayStructPayloadResponse,
            ClosedTargetMarker,
        >(
            (v,),
            0x313769ab1b770c90,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.v)
    }

    pub fn r#two_way_table_payload(
        &self,
        mut payload: &ClosedTargetTwoWayTablePayloadRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ClosedTargetTwoWayTablePayloadResponse, fidl::Error> {
        let _response = self.client.send_query::<
            ClosedTargetTwoWayTablePayloadRequest,
            ClosedTargetTwoWayTablePayloadResponse,
            ClosedTargetMarker,
        >(
            payload,
            0x631f7f27b6872baa,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    pub fn r#two_way_union_payload(
        &self,
        mut payload: &ClosedTargetTwoWayUnionPayloadRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ClosedTargetTwoWayUnionPayloadResponse, fidl::Error> {
        let _response = self.client.send_query::<
            ClosedTargetTwoWayUnionPayloadRequest,
            ClosedTargetTwoWayUnionPayloadResponse,
            ClosedTargetMarker,
        >(
            payload,
            0x77d0365370536dba,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    pub fn r#two_way_result(
        &self,
        mut payload: &ClosedTargetTwoWayResultRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ClosedTargetTwoWayResultResult, fidl::Error> {
        let _response = self.client.send_query::<
            ClosedTargetTwoWayResultRequest,
            fidl::encoding::ResultType<ClosedTargetTwoWayResultResponse, u32>,
            ClosedTargetMarker,
        >(
            payload,
            0xb32549e6f50894c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.payload))
    }

    pub fn r#get_handle_rights(
        &self,
        mut handle: fidl::NullableHandle,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl::Rights, fidl::Error> {
        let _response = self.client.send_query::<
            ClosedTargetGetHandleRightsRequest,
            ClosedTargetGetHandleRightsResponse,
            ClosedTargetMarker,
        >(
            (handle,),
            0x1098d82f79effbe8,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.rights)
    }

    pub fn r#get_signalable_event_rights(
        &self,
        mut handle: fidl::Event,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl::Rights, fidl::Error> {
        let _response = self.client.send_query::<
            ClosedTargetGetSignalableEventRightsRequest,
            ClosedTargetGetSignalableEventRightsResponse,
            ClosedTargetMarker,
        >(
            (handle,),
            0x698c31448fd5daf,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.rights)
    }

    pub fn r#echo_as_transferable_signalable_event(
        &self,
        mut handle: fidl::NullableHandle,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl::Event, fidl::Error> {
        let _response = self.client.send_query::<
            ClosedTargetEchoAsTransferableSignalableEventRequest,
            ClosedTargetEchoAsTransferableSignalableEventResponse,
            ClosedTargetMarker,
        >(
            (handle,),
            0x5ec627bdc2e02ca0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.handle)
    }

    pub fn r#byte_vector_size(
        &self,
        mut vec: &[u8],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<u32, fidl::Error> {
        let _response = self.client.send_query::<
            ClosedTargetByteVectorSizeRequest,
            ClosedTargetByteVectorSizeResponse,
            ClosedTargetMarker,
        >(
            (vec,),
            0x104b2f9aa8b7fe25,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.n)
    }

    pub fn r#handle_vector_size(
        &self,
        mut vec: Vec<fidl::Event>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<u32, fidl::Error> {
        let _response = self.client.send_query::<
            ClosedTargetHandleVectorSizeRequest,
            ClosedTargetHandleVectorSizeResponse,
            ClosedTargetMarker,
        >(
            (vec.as_mut(),),
            0x4c1ac83570a98537,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.n)
    }

    pub fn r#create_n_byte_vector(
        &self,
        mut n: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<u8>, fidl::Error> {
        let _response = self.client.send_query::<
            ClosedTargetCreateNByteVectorRequest,
            ClosedTargetCreateNByteVectorResponse,
            ClosedTargetMarker,
        >(
            (n,),
            0x1ecd88ef664e9c61,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.vec)
    }

    pub fn r#create_n_handle_vector(
        &self,
        mut n: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<fidl::Event>, fidl::Error> {
        let _response = self.client.send_query::<
            ClosedTargetCreateNHandleVectorRequest,
            ClosedTargetCreateNHandleVectorResponse,
            ClosedTargetMarker,
        >(
            (n,),
            0x26341ba1fa66813d,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.vec)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ClosedTargetProxy {
    type Protocol = ClosedTargetMarker;

    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 ClosedTargetProxy {
    /// Create a new Proxy for fidl.serversuite/ClosedTarget.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ClosedTargetMarker 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) -> ClosedTargetEventStream {
        ClosedTargetEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#one_way_no_payload(&self) -> Result<(), fidl::Error> {
        ClosedTargetProxyInterface::r#one_way_no_payload(self)
    }

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

    pub fn r#two_way_struct_payload(
        &self,
        mut v: i8,
    ) -> fidl::client::QueryResponseFut<i8, fidl::encoding::DefaultFuchsiaResourceDialect> {
        ClosedTargetProxyInterface::r#two_way_struct_payload(self, v)
    }

    pub fn r#two_way_table_payload(
        &self,
        mut payload: &ClosedTargetTwoWayTablePayloadRequest,
    ) -> fidl::client::QueryResponseFut<
        ClosedTargetTwoWayTablePayloadResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ClosedTargetProxyInterface::r#two_way_table_payload(self, payload)
    }

    pub fn r#two_way_union_payload(
        &self,
        mut payload: &ClosedTargetTwoWayUnionPayloadRequest,
    ) -> fidl::client::QueryResponseFut<
        ClosedTargetTwoWayUnionPayloadResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ClosedTargetProxyInterface::r#two_way_union_payload(self, payload)
    }

    pub fn r#two_way_result(
        &self,
        mut payload: &ClosedTargetTwoWayResultRequest,
    ) -> fidl::client::QueryResponseFut<
        ClosedTargetTwoWayResultResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ClosedTargetProxyInterface::r#two_way_result(self, payload)
    }

    pub fn r#get_handle_rights(
        &self,
        mut handle: fidl::NullableHandle,
    ) -> fidl::client::QueryResponseFut<fidl::Rights, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        ClosedTargetProxyInterface::r#get_handle_rights(self, handle)
    }

    pub fn r#get_signalable_event_rights(
        &self,
        mut handle: fidl::Event,
    ) -> fidl::client::QueryResponseFut<fidl::Rights, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        ClosedTargetProxyInterface::r#get_signalable_event_rights(self, handle)
    }

    pub fn r#echo_as_transferable_signalable_event(
        &self,
        mut handle: fidl::NullableHandle,
    ) -> fidl::client::QueryResponseFut<fidl::Event, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        ClosedTargetProxyInterface::r#echo_as_transferable_signalable_event(self, handle)
    }

    pub fn r#byte_vector_size(
        &self,
        mut vec: &[u8],
    ) -> fidl::client::QueryResponseFut<u32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        ClosedTargetProxyInterface::r#byte_vector_size(self, vec)
    }

    pub fn r#handle_vector_size(
        &self,
        mut vec: Vec<fidl::Event>,
    ) -> fidl::client::QueryResponseFut<u32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        ClosedTargetProxyInterface::r#handle_vector_size(self, vec)
    }

    pub fn r#create_n_byte_vector(
        &self,
        mut n: u32,
    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        ClosedTargetProxyInterface::r#create_n_byte_vector(self, n)
    }

    pub fn r#create_n_handle_vector(
        &self,
        mut n: u32,
    ) -> fidl::client::QueryResponseFut<
        Vec<fidl::Event>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ClosedTargetProxyInterface::r#create_n_handle_vector(self, n)
    }
}

impl ClosedTargetProxyInterface for ClosedTargetProxy {
    fn r#one_way_no_payload(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x66bd5fe1d4c019e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    type TwoWayStructPayloadResponseFut =
        fidl::client::QueryResponseFut<i8, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#two_way_struct_payload(&self, mut v: i8) -> Self::TwoWayStructPayloadResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i8, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ClosedTargetTwoWayStructPayloadResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x313769ab1b770c90,
            >(_buf?)?;
            Ok(_response.v)
        }
        self.client.send_query_and_decode::<ClosedTargetTwoWayStructPayloadRequest, i8>(
            (v,),
            0x313769ab1b770c90,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

    type TwoWayResultResponseFut = fidl::client::QueryResponseFut<
        ClosedTargetTwoWayResultResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#two_way_result(
        &self,
        mut payload: &ClosedTargetTwoWayResultRequest,
    ) -> Self::TwoWayResultResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ClosedTargetTwoWayResultResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ClosedTargetTwoWayResultResponse, u32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xb32549e6f50894c,
            >(_buf?)?;
            Ok(_response.map(|x| x.payload))
        }
        self.client.send_query_and_decode::<
            ClosedTargetTwoWayResultRequest,
            ClosedTargetTwoWayResultResult,
        >(
            payload,
            0xb32549e6f50894c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetHandleRightsResponseFut =
        fidl::client::QueryResponseFut<fidl::Rights, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_handle_rights(
        &self,
        mut handle: fidl::NullableHandle,
    ) -> Self::GetHandleRightsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl::Rights, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ClosedTargetGetHandleRightsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1098d82f79effbe8,
            >(_buf?)?;
            Ok(_response.rights)
        }
        self.client.send_query_and_decode::<ClosedTargetGetHandleRightsRequest, fidl::Rights>(
            (handle,),
            0x1098d82f79effbe8,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetSignalableEventRightsResponseFut =
        fidl::client::QueryResponseFut<fidl::Rights, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_signalable_event_rights(
        &self,
        mut handle: fidl::Event,
    ) -> Self::GetSignalableEventRightsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl::Rights, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ClosedTargetGetSignalableEventRightsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x698c31448fd5daf,
            >(_buf?)?;
            Ok(_response.rights)
        }
        self.client
            .send_query_and_decode::<ClosedTargetGetSignalableEventRightsRequest, fidl::Rights>(
                (handle,),
                0x698c31448fd5daf,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type EchoAsTransferableSignalableEventResponseFut =
        fidl::client::QueryResponseFut<fidl::Event, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#echo_as_transferable_signalable_event(
        &self,
        mut handle: fidl::NullableHandle,
    ) -> Self::EchoAsTransferableSignalableEventResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl::Event, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ClosedTargetEchoAsTransferableSignalableEventResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5ec627bdc2e02ca0,
            >(_buf?)?;
            Ok(_response.handle)
        }
        self.client.send_query_and_decode::<
            ClosedTargetEchoAsTransferableSignalableEventRequest,
            fidl::Event,
        >(
            (handle,),
            0x5ec627bdc2e02ca0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ByteVectorSizeResponseFut =
        fidl::client::QueryResponseFut<u32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#byte_vector_size(&self, mut vec: &[u8]) -> Self::ByteVectorSizeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ClosedTargetByteVectorSizeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x104b2f9aa8b7fe25,
            >(_buf?)?;
            Ok(_response.n)
        }
        self.client.send_query_and_decode::<ClosedTargetByteVectorSizeRequest, u32>(
            (vec,),
            0x104b2f9aa8b7fe25,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type HandleVectorSizeResponseFut =
        fidl::client::QueryResponseFut<u32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#handle_vector_size(&self, mut vec: Vec<fidl::Event>) -> Self::HandleVectorSizeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ClosedTargetHandleVectorSizeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4c1ac83570a98537,
            >(_buf?)?;
            Ok(_response.n)
        }
        self.client.send_query_and_decode::<ClosedTargetHandleVectorSizeRequest, u32>(
            (vec.as_mut(),),
            0x4c1ac83570a98537,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CreateNByteVectorResponseFut =
        fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#create_n_byte_vector(&self, mut n: u32) -> Self::CreateNByteVectorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<u8>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ClosedTargetCreateNByteVectorResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ecd88ef664e9c61,
            >(_buf?)?;
            Ok(_response.vec)
        }
        self.client.send_query_and_decode::<ClosedTargetCreateNByteVectorRequest, Vec<u8>>(
            (n,),
            0x1ecd88ef664e9c61,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CreateNHandleVectorResponseFut = fidl::client::QueryResponseFut<
        Vec<fidl::Event>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_n_handle_vector(&self, mut n: u32) -> Self::CreateNHandleVectorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<fidl::Event>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ClosedTargetCreateNHandleVectorResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x26341ba1fa66813d,
            >(_buf?)?;
            Ok(_response.vec)
        }
        self.client
            .send_query_and_decode::<ClosedTargetCreateNHandleVectorRequest, Vec<fidl::Event>>(
                (n,),
                0x26341ba1fa66813d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fidl.serversuite/ClosedTarget.
pub struct ClosedTargetRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for ClosedTargetRequestStream {
    type Protocol = ClosedTargetMarker;
    type ControlHandle = ClosedTargetControlHandle;

    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 {
        ClosedTargetControlHandle { 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 ClosedTargetRequestStream {
    type Item = Result<ClosedTargetRequest, 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 ClosedTargetRequestStream 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 {
                    0x66bd5fe1d4c019e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::OneWayNoPayload { control_handle })
                    }
                    0x5bda1d1c46a5ae5f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::TwoWayNoPayload {
                            responder: ClosedTargetTwoWayNoPayloadResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x313769ab1b770c90 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClosedTargetTwoWayStructPayloadRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClosedTargetTwoWayStructPayloadRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::TwoWayStructPayload {
                            v: req.v,

                            responder: ClosedTargetTwoWayStructPayloadResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x631f7f27b6872baa => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClosedTargetTwoWayTablePayloadRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClosedTargetTwoWayTablePayloadRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::TwoWayTablePayload {
                            payload: req,
                            responder: ClosedTargetTwoWayTablePayloadResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x77d0365370536dba => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClosedTargetTwoWayUnionPayloadRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClosedTargetTwoWayUnionPayloadRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::TwoWayUnionPayload {
                            payload: req,
                            responder: ClosedTargetTwoWayUnionPayloadResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xb32549e6f50894c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClosedTargetTwoWayResultRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClosedTargetTwoWayResultRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::TwoWayResult {
                            payload: req,
                            responder: ClosedTargetTwoWayResultResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1098d82f79effbe8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClosedTargetGetHandleRightsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClosedTargetGetHandleRightsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::GetHandleRights {
                            handle: req.handle,

                            responder: ClosedTargetGetHandleRightsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x698c31448fd5daf => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClosedTargetGetSignalableEventRightsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClosedTargetGetSignalableEventRightsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::GetSignalableEventRights {
                            handle: req.handle,

                            responder: ClosedTargetGetSignalableEventRightsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5ec627bdc2e02ca0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClosedTargetEchoAsTransferableSignalableEventRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClosedTargetEchoAsTransferableSignalableEventRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::EchoAsTransferableSignalableEvent {
                            handle: req.handle,

                            responder: ClosedTargetEchoAsTransferableSignalableEventResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x104b2f9aa8b7fe25 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClosedTargetByteVectorSizeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClosedTargetByteVectorSizeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::ByteVectorSize {
                            vec: req.vec,

                            responder: ClosedTargetByteVectorSizeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4c1ac83570a98537 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClosedTargetHandleVectorSizeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClosedTargetHandleVectorSizeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::HandleVectorSize {
                            vec: req.vec,

                            responder: ClosedTargetHandleVectorSizeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ecd88ef664e9c61 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClosedTargetCreateNByteVectorRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClosedTargetCreateNByteVectorRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::CreateNByteVector {
                            n: req.n,

                            responder: ClosedTargetCreateNByteVectorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x26341ba1fa66813d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ClosedTargetCreateNHandleVectorRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClosedTargetCreateNHandleVectorRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::CreateNHandleVector {
                            n: req.n,

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

#[derive(Debug)]
pub enum ClosedTargetRequest {
    OneWayNoPayload {
        control_handle: ClosedTargetControlHandle,
    },
    TwoWayNoPayload {
        responder: ClosedTargetTwoWayNoPayloadResponder,
    },
    TwoWayStructPayload {
        v: i8,
        responder: ClosedTargetTwoWayStructPayloadResponder,
    },
    TwoWayTablePayload {
        payload: ClosedTargetTwoWayTablePayloadRequest,
        responder: ClosedTargetTwoWayTablePayloadResponder,
    },
    TwoWayUnionPayload {
        payload: ClosedTargetTwoWayUnionPayloadRequest,
        responder: ClosedTargetTwoWayUnionPayloadResponder,
    },
    TwoWayResult {
        payload: ClosedTargetTwoWayResultRequest,
        responder: ClosedTargetTwoWayResultResponder,
    },
    GetHandleRights {
        handle: fidl::NullableHandle,
        responder: ClosedTargetGetHandleRightsResponder,
    },
    GetSignalableEventRights {
        handle: fidl::Event,
        responder: ClosedTargetGetSignalableEventRightsResponder,
    },
    EchoAsTransferableSignalableEvent {
        handle: fidl::NullableHandle,
        responder: ClosedTargetEchoAsTransferableSignalableEventResponder,
    },
    ByteVectorSize {
        vec: Vec<u8>,
        responder: ClosedTargetByteVectorSizeResponder,
    },
    HandleVectorSize {
        vec: Vec<fidl::Event>,
        responder: ClosedTargetHandleVectorSizeResponder,
    },
    CreateNByteVector {
        n: u32,
        responder: ClosedTargetCreateNByteVectorResponder,
    },
    CreateNHandleVector {
        n: u32,
        responder: ClosedTargetCreateNHandleVectorResponder,
    },
}

impl ClosedTargetRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_one_way_no_payload(self) -> Option<(ClosedTargetControlHandle)> {
        if let ClosedTargetRequest::OneWayNoPayload { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_two_way_no_payload(self) -> Option<(ClosedTargetTwoWayNoPayloadResponder)> {
        if let ClosedTargetRequest::TwoWayNoPayload { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_two_way_struct_payload(
        self,
    ) -> Option<(i8, ClosedTargetTwoWayStructPayloadResponder)> {
        if let ClosedTargetRequest::TwoWayStructPayload { v, responder } = self {
            Some((v, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_two_way_table_payload(
        self,
    ) -> Option<(ClosedTargetTwoWayTablePayloadRequest, ClosedTargetTwoWayTablePayloadResponder)>
    {
        if let ClosedTargetRequest::TwoWayTablePayload { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_two_way_union_payload(
        self,
    ) -> Option<(ClosedTargetTwoWayUnionPayloadRequest, ClosedTargetTwoWayUnionPayloadResponder)>
    {
        if let ClosedTargetRequest::TwoWayUnionPayload { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_two_way_result(
        self,
    ) -> Option<(ClosedTargetTwoWayResultRequest, ClosedTargetTwoWayResultResponder)> {
        if let ClosedTargetRequest::TwoWayResult { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_handle_rights(
        self,
    ) -> Option<(fidl::NullableHandle, ClosedTargetGetHandleRightsResponder)> {
        if let ClosedTargetRequest::GetHandleRights { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_signalable_event_rights(
        self,
    ) -> Option<(fidl::Event, ClosedTargetGetSignalableEventRightsResponder)> {
        if let ClosedTargetRequest::GetSignalableEventRights { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_echo_as_transferable_signalable_event(
        self,
    ) -> Option<(fidl::NullableHandle, ClosedTargetEchoAsTransferableSignalableEventResponder)>
    {
        if let ClosedTargetRequest::EchoAsTransferableSignalableEvent { handle, responder } = self {
            Some((handle, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_byte_vector_size(self) -> Option<(Vec<u8>, ClosedTargetByteVectorSizeResponder)> {
        if let ClosedTargetRequest::ByteVectorSize { vec, responder } = self {
            Some((vec, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_handle_vector_size(
        self,
    ) -> Option<(Vec<fidl::Event>, ClosedTargetHandleVectorSizeResponder)> {
        if let ClosedTargetRequest::HandleVectorSize { vec, responder } = self {
            Some((vec, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_n_byte_vector(
        self,
    ) -> Option<(u32, ClosedTargetCreateNByteVectorResponder)> {
        if let ClosedTargetRequest::CreateNByteVector { n, responder } = self {
            Some((n, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_n_handle_vector(
        self,
    ) -> Option<(u32, ClosedTargetCreateNHandleVectorResponder)> {
        if let ClosedTargetRequest::CreateNHandleVector { n, responder } = self {
            Some((n, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ClosedTargetRequest::OneWayNoPayload { .. } => "one_way_no_payload",
            ClosedTargetRequest::TwoWayNoPayload { .. } => "two_way_no_payload",
            ClosedTargetRequest::TwoWayStructPayload { .. } => "two_way_struct_payload",
            ClosedTargetRequest::TwoWayTablePayload { .. } => "two_way_table_payload",
            ClosedTargetRequest::TwoWayUnionPayload { .. } => "two_way_union_payload",
            ClosedTargetRequest::TwoWayResult { .. } => "two_way_result",
            ClosedTargetRequest::GetHandleRights { .. } => "get_handle_rights",
            ClosedTargetRequest::GetSignalableEventRights { .. } => "get_signalable_event_rights",
            ClosedTargetRequest::EchoAsTransferableSignalableEvent { .. } => {
                "echo_as_transferable_signalable_event"
            }
            ClosedTargetRequest::ByteVectorSize { .. } => "byte_vector_size",
            ClosedTargetRequest::HandleVectorSize { .. } => "handle_vector_size",
            ClosedTargetRequest::CreateNByteVector { .. } => "create_n_byte_vector",
            ClosedTargetRequest::CreateNHandleVector { .. } => "create_n_handle_vector",
        }
    }
}

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

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

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

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

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

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

impl ClosedTargetControlHandle {}

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut v: i8) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ClosedTargetTwoWayStructPayloadResponse>(
            (v,),
            self.tx_id,
            0x313769ab1b770c90,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut result: Result<&str, u32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<ClosedTargetTwoWayResultResponse, u32>>(
                result.map(|payload| (payload,)),
                self.tx_id,
                0xb32549e6f50894c,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

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

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

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

    fn send_raw(&self, mut rights: fidl::Rights) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ClosedTargetGetHandleRightsResponse>(
            (rights,),
            self.tx_id,
            0x1098d82f79effbe8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut rights: fidl::Rights) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ClosedTargetGetSignalableEventRightsResponse>(
            (rights,),
            self.tx_id,
            0x698c31448fd5daf,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

    fn send_raw(&self, mut handle: fidl::Event) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ClosedTargetEchoAsTransferableSignalableEventResponse>(
            (handle,),
            self.tx_id,
            0x5ec627bdc2e02ca0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self, mut vec: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ClosedTargetCreateNByteVectorResponse>(
            (vec,),
            self.tx_id,
            0x1ecd88ef664e9c61,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut vec: Vec<fidl::Event>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ClosedTargetCreateNHandleVectorResponse>(
            (vec.as_mut(),),
            self.tx_id,
            0x26341ba1fa66813d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for OpenTargetMarker {
    type Proxy = OpenTargetProxy;
    type RequestStream = OpenTargetRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = OpenTargetSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) OpenTarget";
}
pub type OpenTargetStrictTwoWayErrResult = Result<(), i32>;
pub type OpenTargetStrictTwoWayFieldsErrResult = Result<i32, i32>;
pub type OpenTargetFlexibleTwoWayErrResult = Result<(), i32>;
pub type OpenTargetFlexibleTwoWayFieldsErrResult = Result<i32, i32>;

pub trait OpenTargetProxyInterface: Send + Sync {
    fn r#strict_one_way(&self) -> Result<(), fidl::Error>;
    fn r#flexible_one_way(&self) -> Result<(), fidl::Error>;
    type StrictTwoWayResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#strict_two_way(&self) -> Self::StrictTwoWayResponseFut;
    type StrictTwoWayFieldsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
        + Send;
    fn r#strict_two_way_fields(&self, reply_with: i32) -> Self::StrictTwoWayFieldsResponseFut;
    type StrictTwoWayErrResponseFut: std::future::Future<Output = Result<OpenTargetStrictTwoWayErrResult, fidl::Error>>
        + Send;
    fn r#strict_two_way_err(
        &self,
        payload: &OpenTargetStrictTwoWayErrRequest,
    ) -> Self::StrictTwoWayErrResponseFut;
    type StrictTwoWayFieldsErrResponseFut: std::future::Future<Output = Result<OpenTargetStrictTwoWayFieldsErrResult, fidl::Error>>
        + Send;
    fn r#strict_two_way_fields_err(
        &self,
        payload: &OpenTargetStrictTwoWayFieldsErrRequest,
    ) -> Self::StrictTwoWayFieldsErrResponseFut;
    type FlexibleTwoWayResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#flexible_two_way(&self) -> Self::FlexibleTwoWayResponseFut;
    type FlexibleTwoWayFieldsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
        + Send;
    fn r#flexible_two_way_fields(&self, reply_with: i32) -> Self::FlexibleTwoWayFieldsResponseFut;
    type FlexibleTwoWayErrResponseFut: std::future::Future<Output = Result<OpenTargetFlexibleTwoWayErrResult, fidl::Error>>
        + Send;
    fn r#flexible_two_way_err(
        &self,
        payload: &OpenTargetFlexibleTwoWayErrRequest,
    ) -> Self::FlexibleTwoWayErrResponseFut;
    type FlexibleTwoWayFieldsErrResponseFut: std::future::Future<Output = Result<OpenTargetFlexibleTwoWayFieldsErrResult, fidl::Error>>
        + Send;
    fn r#flexible_two_way_fields_err(
        &self,
        payload: &OpenTargetFlexibleTwoWayFieldsErrRequest,
    ) -> Self::FlexibleTwoWayFieldsErrResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct OpenTargetSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for OpenTargetSynchronousProxy {
    type Proxy = OpenTargetProxy;
    type Protocol = OpenTargetMarker;

    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 OpenTargetSynchronousProxy {
    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<OpenTargetEvent, fidl::Error> {
        OpenTargetEvent::decode(self.client.wait_for_event::<OpenTargetMarker>(deadline)?)
    }

    pub fn r#strict_one_way(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x24dd8be3750aba9b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#flexible_one_way(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x421bbeb2bbc84a58,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

    pub fn r#strict_two_way(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::EmptyPayload,
            OpenTargetMarker,
        >(
            (),
            0x70020c582a57ef03,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    pub fn r#strict_two_way_fields(
        &self,
        mut reply_with: i32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            OpenTargetStrictTwoWayFieldsRequest,
            OpenTargetStrictTwoWayFieldsResponse,
            OpenTargetMarker,
        >(
            (reply_with,),
            0x2be6e1cc40008010,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.some_field)
    }

    pub fn r#strict_two_way_err(
        &self,
        mut payload: &OpenTargetStrictTwoWayErrRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<OpenTargetStrictTwoWayErrResult, fidl::Error> {
        let _response = self.client.send_query::<
            OpenTargetStrictTwoWayErrRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
            OpenTargetMarker,
        >(
            payload,
            0x6efc16069ebd0b2c,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#strict_two_way_fields_err(
        &self,
        mut payload: &OpenTargetStrictTwoWayFieldsErrRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<OpenTargetStrictTwoWayFieldsErrResult, fidl::Error> {
        let _response = self.client.send_query::<
            OpenTargetStrictTwoWayFieldsErrRequest,
            fidl::encoding::ResultType<OpenTargetStrictTwoWayFieldsErrResponse, i32>,
            OpenTargetMarker,
        >(
            payload,
            0x309c8adda770fcf0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.some_field))
    }

    pub fn r#flexible_two_way(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
            OpenTargetMarker,
        >(
            (),
            0x19f932dac7810c71,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<OpenTargetMarker>("flexible_two_way")?;
        Ok(_response)
    }

    pub fn r#flexible_two_way_fields(
        &self,
        mut reply_with: i32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<i32, fidl::Error> {
        let _response = self.client.send_query::<
            OpenTargetFlexibleTwoWayFieldsRequest,
            fidl::encoding::FlexibleType<OpenTargetFlexibleTwoWayFieldsResponse>,
            OpenTargetMarker,
        >(
            (reply_with,),
            0x47cca5ddb4207774,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<OpenTargetMarker>("flexible_two_way_fields")?;
        Ok(_response.some_field)
    }

    pub fn r#flexible_two_way_err(
        &self,
        mut payload: &OpenTargetFlexibleTwoWayErrRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<OpenTargetFlexibleTwoWayErrResult, fidl::Error> {
        let _response = self.client.send_query::<
            OpenTargetFlexibleTwoWayErrRequest,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
            OpenTargetMarker,
        >(
            payload,
            0x52aa19681fea3a0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<OpenTargetMarker>("flexible_two_way_err")?;
        Ok(_response.map(|x| x))
    }

    pub fn r#flexible_two_way_fields_err(
        &self,
        mut payload: &OpenTargetFlexibleTwoWayFieldsErrRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<OpenTargetFlexibleTwoWayFieldsErrResult, fidl::Error> {
        let _response = self.client.send_query::<
            OpenTargetFlexibleTwoWayFieldsErrRequest,
            fidl::encoding::FlexibleResultType<OpenTargetFlexibleTwoWayFieldsErrResponse, i32>,
            OpenTargetMarker,
        >(
            payload,
            0x1ab7dd4c6a3650b6,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<OpenTargetMarker>("flexible_two_way_fields_err")?;
        Ok(_response.map(|x| x.some_field))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for OpenTargetProxy {
    type Protocol = OpenTargetMarker;

    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 OpenTargetProxy {
    /// Create a new Proxy for fidl.serversuite/OpenTarget.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <OpenTargetMarker 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) -> OpenTargetEventStream {
        OpenTargetEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#strict_one_way(&self) -> Result<(), fidl::Error> {
        OpenTargetProxyInterface::r#strict_one_way(self)
    }

    pub fn r#flexible_one_way(&self) -> Result<(), fidl::Error> {
        OpenTargetProxyInterface::r#flexible_one_way(self)
    }

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

    pub fn r#strict_two_way_fields(
        &self,
        mut reply_with: i32,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        OpenTargetProxyInterface::r#strict_two_way_fields(self, reply_with)
    }

    pub fn r#strict_two_way_err(
        &self,
        mut payload: &OpenTargetStrictTwoWayErrRequest,
    ) -> fidl::client::QueryResponseFut<
        OpenTargetStrictTwoWayErrResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        OpenTargetProxyInterface::r#strict_two_way_err(self, payload)
    }

    pub fn r#strict_two_way_fields_err(
        &self,
        mut payload: &OpenTargetStrictTwoWayFieldsErrRequest,
    ) -> fidl::client::QueryResponseFut<
        OpenTargetStrictTwoWayFieldsErrResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        OpenTargetProxyInterface::r#strict_two_way_fields_err(self, payload)
    }

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

    pub fn r#flexible_two_way_fields(
        &self,
        mut reply_with: i32,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        OpenTargetProxyInterface::r#flexible_two_way_fields(self, reply_with)
    }

    pub fn r#flexible_two_way_err(
        &self,
        mut payload: &OpenTargetFlexibleTwoWayErrRequest,
    ) -> fidl::client::QueryResponseFut<
        OpenTargetFlexibleTwoWayErrResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        OpenTargetProxyInterface::r#flexible_two_way_err(self, payload)
    }

    pub fn r#flexible_two_way_fields_err(
        &self,
        mut payload: &OpenTargetFlexibleTwoWayFieldsErrRequest,
    ) -> fidl::client::QueryResponseFut<
        OpenTargetFlexibleTwoWayFieldsErrResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        OpenTargetProxyInterface::r#flexible_two_way_fields_err(self, payload)
    }
}

impl OpenTargetProxyInterface for OpenTargetProxy {
    fn r#strict_one_way(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x24dd8be3750aba9b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#flexible_one_way(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x421bbeb2bbc84a58,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }

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

    type StrictTwoWayFieldsResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#strict_two_way_fields(&self, mut reply_with: i32) -> Self::StrictTwoWayFieldsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                OpenTargetStrictTwoWayFieldsResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2be6e1cc40008010,
            >(_buf?)?;
            Ok(_response.some_field)
        }
        self.client.send_query_and_decode::<OpenTargetStrictTwoWayFieldsRequest, i32>(
            (reply_with,),
            0x2be6e1cc40008010,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StrictTwoWayErrResponseFut = fidl::client::QueryResponseFut<
        OpenTargetStrictTwoWayErrResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#strict_two_way_err(
        &self,
        mut payload: &OpenTargetStrictTwoWayErrRequest,
    ) -> Self::StrictTwoWayErrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<OpenTargetStrictTwoWayErrResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6efc16069ebd0b2c,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            OpenTargetStrictTwoWayErrRequest,
            OpenTargetStrictTwoWayErrResult,
        >(
            payload,
            0x6efc16069ebd0b2c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StrictTwoWayFieldsErrResponseFut = fidl::client::QueryResponseFut<
        OpenTargetStrictTwoWayFieldsErrResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#strict_two_way_fields_err(
        &self,
        mut payload: &OpenTargetStrictTwoWayFieldsErrRequest,
    ) -> Self::StrictTwoWayFieldsErrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<OpenTargetStrictTwoWayFieldsErrResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<OpenTargetStrictTwoWayFieldsErrResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x309c8adda770fcf0,
            >(_buf?)?;
            Ok(_response.map(|x| x.some_field))
        }
        self.client.send_query_and_decode::<
            OpenTargetStrictTwoWayFieldsErrRequest,
            OpenTargetStrictTwoWayFieldsErrResult,
        >(
            payload,
            0x309c8adda770fcf0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type FlexibleTwoWayResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#flexible_two_way(&self) -> Self::FlexibleTwoWayResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x19f932dac7810c71,
            >(_buf?)?
            .into_result::<OpenTargetMarker>("flexible_two_way")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x19f932dac7810c71,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type FlexibleTwoWayFieldsResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#flexible_two_way_fields(
        &self,
        mut reply_with: i32,
    ) -> Self::FlexibleTwoWayFieldsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<i32, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleType<OpenTargetFlexibleTwoWayFieldsResponse>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x47cca5ddb4207774,
            >(_buf?)?
            .into_result::<OpenTargetMarker>("flexible_two_way_fields")?;
            Ok(_response.some_field)
        }
        self.client.send_query_and_decode::<OpenTargetFlexibleTwoWayFieldsRequest, i32>(
            (reply_with,),
            0x47cca5ddb4207774,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type FlexibleTwoWayErrResponseFut = fidl::client::QueryResponseFut<
        OpenTargetFlexibleTwoWayErrResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#flexible_two_way_err(
        &self,
        mut payload: &OpenTargetFlexibleTwoWayErrRequest,
    ) -> Self::FlexibleTwoWayErrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<OpenTargetFlexibleTwoWayErrResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x52aa19681fea3a0,
            >(_buf?)?
            .into_result::<OpenTargetMarker>("flexible_two_way_err")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            OpenTargetFlexibleTwoWayErrRequest,
            OpenTargetFlexibleTwoWayErrResult,
        >(
            payload,
            0x52aa19681fea3a0,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type FlexibleTwoWayFieldsErrResponseFut = fidl::client::QueryResponseFut<
        OpenTargetFlexibleTwoWayFieldsErrResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#flexible_two_way_fields_err(
        &self,
        mut payload: &OpenTargetFlexibleTwoWayFieldsErrRequest,
    ) -> Self::FlexibleTwoWayFieldsErrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<OpenTargetFlexibleTwoWayFieldsErrResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::FlexibleResultType<OpenTargetFlexibleTwoWayFieldsErrResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ab7dd4c6a3650b6,
            >(_buf?)?
            .into_result::<OpenTargetMarker>("flexible_two_way_fields_err")?;
            Ok(_response.map(|x| x.some_field))
        }
        self.client.send_query_and_decode::<
            OpenTargetFlexibleTwoWayFieldsErrRequest,
            OpenTargetFlexibleTwoWayFieldsErrResult,
        >(
            payload,
            0x1ab7dd4c6a3650b6,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }
}

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

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

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

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

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

impl OpenTargetEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_strict_event(self) -> Option<()> {
        if let OpenTargetEvent::StrictEvent {} = self { Some(()) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_flexible_event(self) -> Option<()> {
        if let OpenTargetEvent::FlexibleEvent {} = self { Some(()) } else { None }
    }

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

/// A Stream of incoming requests for fidl.serversuite/OpenTarget.
pub struct OpenTargetRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for OpenTargetRequestStream {
    type Protocol = OpenTargetMarker;
    type ControlHandle = OpenTargetControlHandle;

    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 {
        OpenTargetControlHandle { 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 OpenTargetRequestStream {
    type Item = Result<OpenTargetRequest, 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 OpenTargetRequestStream 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 {
                    0x24dd8be3750aba9b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = OpenTargetControlHandle { inner: this.inner.clone() };
                        Ok(OpenTargetRequest::StrictOneWay { control_handle })
                    }
                    0x421bbeb2bbc84a58 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = OpenTargetControlHandle { inner: this.inner.clone() };
                        Ok(OpenTargetRequest::FlexibleOneWay { control_handle })
                    }
                    0x70020c582a57ef03 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = OpenTargetControlHandle { inner: this.inner.clone() };
                        Ok(OpenTargetRequest::StrictTwoWay {
                            responder: OpenTargetStrictTwoWayResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2be6e1cc40008010 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            OpenTargetStrictTwoWayFieldsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<OpenTargetStrictTwoWayFieldsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = OpenTargetControlHandle { inner: this.inner.clone() };
                        Ok(OpenTargetRequest::StrictTwoWayFields {
                            reply_with: req.reply_with,

                            responder: OpenTargetStrictTwoWayFieldsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6efc16069ebd0b2c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            OpenTargetStrictTwoWayErrRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<OpenTargetStrictTwoWayErrRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = OpenTargetControlHandle { inner: this.inner.clone() };
                        Ok(OpenTargetRequest::StrictTwoWayErr {
                            payload: req,
                            responder: OpenTargetStrictTwoWayErrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x309c8adda770fcf0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            OpenTargetStrictTwoWayFieldsErrRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<OpenTargetStrictTwoWayFieldsErrRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = OpenTargetControlHandle { inner: this.inner.clone() };
                        Ok(OpenTargetRequest::StrictTwoWayFieldsErr {
                            payload: req,
                            responder: OpenTargetStrictTwoWayFieldsErrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x19f932dac7810c71 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = OpenTargetControlHandle { inner: this.inner.clone() };
                        Ok(OpenTargetRequest::FlexibleTwoWay {
                            responder: OpenTargetFlexibleTwoWayResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x47cca5ddb4207774 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            OpenTargetFlexibleTwoWayFieldsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<OpenTargetFlexibleTwoWayFieldsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = OpenTargetControlHandle { inner: this.inner.clone() };
                        Ok(OpenTargetRequest::FlexibleTwoWayFields {
                            reply_with: req.reply_with,

                            responder: OpenTargetFlexibleTwoWayFieldsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x52aa19681fea3a0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            OpenTargetFlexibleTwoWayErrRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<OpenTargetFlexibleTwoWayErrRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = OpenTargetControlHandle { inner: this.inner.clone() };
                        Ok(OpenTargetRequest::FlexibleTwoWayErr {
                            payload: req,
                            responder: OpenTargetFlexibleTwoWayErrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ab7dd4c6a3650b6 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            OpenTargetFlexibleTwoWayFieldsErrRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<OpenTargetFlexibleTwoWayFieldsErrRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = OpenTargetControlHandle { inner: this.inner.clone() };
                        Ok(OpenTargetRequest::FlexibleTwoWayFieldsErr {
                            payload: req,
                            responder: OpenTargetFlexibleTwoWayFieldsErrResponder {
                                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(OpenTargetRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: OpenTargetControlHandle { 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(OpenTargetRequest::_UnknownMethod {
                            ordinal: header.ordinal,
                            control_handle: OpenTargetControlHandle { inner: this.inner.clone() },
                            method_type: fidl::MethodType::TwoWay,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <OpenTargetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum OpenTargetRequest {
    StrictOneWay {
        control_handle: OpenTargetControlHandle,
    },
    FlexibleOneWay {
        control_handle: OpenTargetControlHandle,
    },
    StrictTwoWay {
        responder: OpenTargetStrictTwoWayResponder,
    },
    StrictTwoWayFields {
        reply_with: i32,
        responder: OpenTargetStrictTwoWayFieldsResponder,
    },
    StrictTwoWayErr {
        payload: OpenTargetStrictTwoWayErrRequest,
        responder: OpenTargetStrictTwoWayErrResponder,
    },
    StrictTwoWayFieldsErr {
        payload: OpenTargetStrictTwoWayFieldsErrRequest,
        responder: OpenTargetStrictTwoWayFieldsErrResponder,
    },
    FlexibleTwoWay {
        responder: OpenTargetFlexibleTwoWayResponder,
    },
    FlexibleTwoWayFields {
        reply_with: i32,
        responder: OpenTargetFlexibleTwoWayFieldsResponder,
    },
    FlexibleTwoWayErr {
        payload: OpenTargetFlexibleTwoWayErrRequest,
        responder: OpenTargetFlexibleTwoWayErrResponder,
    },
    FlexibleTwoWayFieldsErr {
        payload: OpenTargetFlexibleTwoWayFieldsErrRequest,
        responder: OpenTargetFlexibleTwoWayFieldsErrResponder,
    },
    /// 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: OpenTargetControlHandle,
        method_type: fidl::MethodType,
    },
}

impl OpenTargetRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_strict_one_way(self) -> Option<(OpenTargetControlHandle)> {
        if let OpenTargetRequest::StrictOneWay { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_flexible_one_way(self) -> Option<(OpenTargetControlHandle)> {
        if let OpenTargetRequest::FlexibleOneWay { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_strict_two_way(self) -> Option<(OpenTargetStrictTwoWayResponder)> {
        if let OpenTargetRequest::StrictTwoWay { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_strict_two_way_fields(
        self,
    ) -> Option<(i32, OpenTargetStrictTwoWayFieldsResponder)> {
        if let OpenTargetRequest::StrictTwoWayFields { reply_with, responder } = self {
            Some((reply_with, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_strict_two_way_err(
        self,
    ) -> Option<(OpenTargetStrictTwoWayErrRequest, OpenTargetStrictTwoWayErrResponder)> {
        if let OpenTargetRequest::StrictTwoWayErr { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_strict_two_way_fields_err(
        self,
    ) -> Option<(OpenTargetStrictTwoWayFieldsErrRequest, OpenTargetStrictTwoWayFieldsErrResponder)>
    {
        if let OpenTargetRequest::StrictTwoWayFieldsErr { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_flexible_two_way(self) -> Option<(OpenTargetFlexibleTwoWayResponder)> {
        if let OpenTargetRequest::FlexibleTwoWay { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_flexible_two_way_fields(
        self,
    ) -> Option<(i32, OpenTargetFlexibleTwoWayFieldsResponder)> {
        if let OpenTargetRequest::FlexibleTwoWayFields { reply_with, responder } = self {
            Some((reply_with, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_flexible_two_way_err(
        self,
    ) -> Option<(OpenTargetFlexibleTwoWayErrRequest, OpenTargetFlexibleTwoWayErrResponder)> {
        if let OpenTargetRequest::FlexibleTwoWayErr { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_flexible_two_way_fields_err(
        self,
    ) -> Option<(
        OpenTargetFlexibleTwoWayFieldsErrRequest,
        OpenTargetFlexibleTwoWayFieldsErrResponder,
    )> {
        if let OpenTargetRequest::FlexibleTwoWayFieldsErr { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            OpenTargetRequest::StrictOneWay { .. } => "strict_one_way",
            OpenTargetRequest::FlexibleOneWay { .. } => "flexible_one_way",
            OpenTargetRequest::StrictTwoWay { .. } => "strict_two_way",
            OpenTargetRequest::StrictTwoWayFields { .. } => "strict_two_way_fields",
            OpenTargetRequest::StrictTwoWayErr { .. } => "strict_two_way_err",
            OpenTargetRequest::StrictTwoWayFieldsErr { .. } => "strict_two_way_fields_err",
            OpenTargetRequest::FlexibleTwoWay { .. } => "flexible_two_way",
            OpenTargetRequest::FlexibleTwoWayFields { .. } => "flexible_two_way_fields",
            OpenTargetRequest::FlexibleTwoWayErr { .. } => "flexible_two_way_err",
            OpenTargetRequest::FlexibleTwoWayFieldsErr { .. } => "flexible_two_way_fields_err",
            OpenTargetRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
                "unknown one-way method"
            }
            OpenTargetRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
                "unknown two-way method"
            }
        }
    }
}

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

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

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

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

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

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

impl OpenTargetControlHandle {
    pub fn send_strict_event(&self) -> Result<(), fidl::Error> {
        self.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            0,
            0x778f95d421c0685,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_flexible_event(&self) -> Result<(), fidl::Error> {
        self.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            0,
            0x43d9ee0dca2bb33e,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
            fidl::encoding::Flexible::new(()),
            self.tx_id,
            0x19f932dac7810c71,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

    fn send_raw(&self, mut some_field: i32) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::FlexibleType<
            OpenTargetFlexibleTwoWayFieldsResponse,
        >>(
            fidl::encoding::Flexible::new((some_field,)),
            self.tx_id,
            0x47cca5ddb4207774,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for RunnerMarker {
    type Proxy = RunnerProxy;
    type RequestStream = RunnerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = RunnerSynchronousProxy;

    const DEBUG_NAME: &'static str = "fidl.serversuite.Runner";
}
impl fidl::endpoints::DiscoverableProtocolMarker for RunnerMarker {}
pub type RunnerStartResult = Result<(), StartError>;

pub trait RunnerProxyInterface: Send + Sync {
    type GetVersionResponseFut: std::future::Future<Output = Result<u64, fidl::Error>> + Send;
    fn r#get_version(&self) -> Self::GetVersionResponseFut;
    type CheckAliveResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#check_alive(&self) -> Self::CheckAliveResponseFut;
    type StartResponseFut: std::future::Future<Output = Result<RunnerStartResult, fidl::Error>>
        + Send;
    fn r#start(&self, test: Test, any_target: AnyTarget) -> Self::StartResponseFut;
    type ShutdownWithEpitaphResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#shutdown_with_epitaph(&self, epitaph_status: i32) -> Self::ShutdownWithEpitaphResponseFut;
    type SendOpenTargetStrictEventResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#send_open_target_strict_event(&self) -> Self::SendOpenTargetStrictEventResponseFut;
    type SendOpenTargetFlexibleEventResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#send_open_target_flexible_event(&self) -> Self::SendOpenTargetFlexibleEventResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct RunnerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for RunnerSynchronousProxy {
    type Proxy = RunnerProxy;
    type Protocol = RunnerMarker;

    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 RunnerSynchronousProxy {
    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<RunnerEvent, fidl::Error> {
        RunnerEvent::decode(self.client.wait_for_event::<RunnerMarker>(deadline)?)
    }

    pub fn r#get_version(&self, ___deadline: zx::MonotonicInstant) -> Result<u64, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, RunnerGetVersionResponse, RunnerMarker>(
                (),
                0x3c70bef2e59d06a7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.version)
    }

    pub fn r#check_alive(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload, RunnerMarker>(
                (),
                0x2449c31d30d6f5b7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#start(
        &self,
        mut test: Test,
        mut any_target: AnyTarget,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<RunnerStartResult, fidl::Error> {
        let _response = self.client.send_query::<RunnerStartRequest, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            StartError,
        >, RunnerMarker>(
            (test, &mut any_target),
            0x2d4735726d30a5b0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#shutdown_with_epitaph(
        &self,
        mut epitaph_status: i32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            RunnerShutdownWithEpitaphRequest,
            fidl::encoding::EmptyPayload,
            RunnerMarker,
        >(
            (epitaph_status,),
            0x7a15369d88e1e8ec,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    pub fn r#send_open_target_strict_event(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload, RunnerMarker>(
                (),
                0x1c3e4452a20c9590,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#send_open_target_flexible_event(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload, RunnerMarker>(
                (),
                0x2d2c9446799baeb6,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for RunnerProxy {
    type Protocol = RunnerMarker;

    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 RunnerProxy {
    /// Create a new Proxy for fidl.serversuite/Runner.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <RunnerMarker 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) -> RunnerEventStream {
        RunnerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#get_version(
        &self,
    ) -> fidl::client::QueryResponseFut<u64, fidl::encoding::DefaultFuchsiaResourceDialect> {
        RunnerProxyInterface::r#get_version(self)
    }

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

    pub fn r#start(
        &self,
        mut test: Test,
        mut any_target: AnyTarget,
    ) -> fidl::client::QueryResponseFut<
        RunnerStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#start(self, test, any_target)
    }

    pub fn r#shutdown_with_epitaph(
        &self,
        mut epitaph_status: i32,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        RunnerProxyInterface::r#shutdown_with_epitaph(self, epitaph_status)
    }

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

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

impl RunnerProxyInterface for RunnerProxy {
    type GetVersionResponseFut =
        fidl::client::QueryResponseFut<u64, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_version(&self) -> Self::GetVersionResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u64, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RunnerGetVersionResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3c70bef2e59d06a7,
            >(_buf?)?;
            Ok(_response.version)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u64>(
            (),
            0x3c70bef2e59d06a7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type StartResponseFut = fidl::client::QueryResponseFut<
        RunnerStartResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#start(&self, mut test: Test, mut any_target: AnyTarget) -> Self::StartResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<RunnerStartResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, StartError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2d4735726d30a5b0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<RunnerStartRequest, RunnerStartResult>(
            (test, &mut any_target),
            0x2d4735726d30a5b0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

#[derive(Debug)]
pub enum RunnerEvent {
    OnTeardown { reason: TeardownReason },
    OnReceivedUnknownMethod { ordinal: u64, unknown_method_type: UnknownMethodType },
    OnReceivedClosedTargetOneWayNoPayload {},
    OnReceivedOpenTargetStrictOneWay {},
    OnReceivedOpenTargetFlexibleOneWay {},
}

impl RunnerEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_teardown(self) -> Option<TeardownReason> {
        if let RunnerEvent::OnTeardown { reason } = self { Some((reason)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_received_unknown_method(self) -> Option<(u64, UnknownMethodType)> {
        if let RunnerEvent::OnReceivedUnknownMethod { ordinal, unknown_method_type } = self {
            Some((ordinal, unknown_method_type))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_received_closed_target_one_way_no_payload(self) -> Option<()> {
        if let RunnerEvent::OnReceivedClosedTargetOneWayNoPayload {} = self {
            Some(())
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_received_open_target_strict_one_way(self) -> Option<()> {
        if let RunnerEvent::OnReceivedOpenTargetStrictOneWay {} = self { Some(()) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_received_open_target_flexible_one_way(self) -> Option<()> {
        if let RunnerEvent::OnReceivedOpenTargetFlexibleOneWay {} = self { Some(()) } else { None }
    }

    /// Decodes a message buffer as a [`RunnerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<RunnerEvent, 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 {
            0x4472273866753acf => {
                let mut out = fidl::new_empty!(
                    RunnerOnTeardownRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RunnerOnTeardownRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((RunnerEvent::OnTeardown { reason: out.reason }))
            }
            0x3c7f8d66a4f4c0e4 => {
                let mut out = fidl::new_empty!(
                    UnknownMethodInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownMethodInfo>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((RunnerEvent::OnReceivedUnknownMethod {
                    ordinal: out.ordinal,
                    unknown_method_type: out.unknown_method_type,
                }))
            }
            0x56915f3fcde32b6f => {
                let mut out = fidl::new_empty!(
                    fidl::encoding::EmptyPayload,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((RunnerEvent::OnReceivedClosedTargetOneWayNoPayload {}))
            }
            0x5b82db8b0ffe97c5 => {
                let mut out = fidl::new_empty!(
                    fidl::encoding::EmptyPayload,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((RunnerEvent::OnReceivedOpenTargetStrictOneWay {}))
            }
            0x2428c34ecface889 => {
                let mut out = fidl::new_empty!(
                    fidl::encoding::EmptyPayload,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((RunnerEvent::OnReceivedOpenTargetFlexibleOneWay {}))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <RunnerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fidl.serversuite/Runner.
pub struct RunnerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for RunnerRequestStream {
    type Protocol = RunnerMarker;
    type ControlHandle = RunnerControlHandle;

    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 {
        RunnerControlHandle { 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 RunnerRequestStream {
    type Item = Result<RunnerRequest, 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 RunnerRequestStream 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 {
                    0x3c70bef2e59d06a7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::GetVersion {
                            responder: RunnerGetVersionResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2449c31d30d6f5b7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::CheckAlive {
                            responder: RunnerCheckAliveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2d4735726d30a5b0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RunnerStartRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RunnerStartRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::Start {
                            test: req.test,
                            any_target: req.any_target,

                            responder: RunnerStartResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7a15369d88e1e8ec => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RunnerShutdownWithEpitaphRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RunnerShutdownWithEpitaphRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::ShutdownWithEpitaph {
                            epitaph_status: req.epitaph_status,

                            responder: RunnerShutdownWithEpitaphResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1c3e4452a20c9590 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::SendOpenTargetStrictEvent {
                            responder: RunnerSendOpenTargetStrictEventResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2d2c9446799baeb6 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::SendOpenTargetFlexibleEvent {
                            responder: RunnerSendOpenTargetFlexibleEventResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <RunnerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum RunnerRequest {
    GetVersion { responder: RunnerGetVersionResponder },
    CheckAlive { responder: RunnerCheckAliveResponder },
    Start { test: Test, any_target: AnyTarget, responder: RunnerStartResponder },
    ShutdownWithEpitaph { epitaph_status: i32, responder: RunnerShutdownWithEpitaphResponder },
    SendOpenTargetStrictEvent { responder: RunnerSendOpenTargetStrictEventResponder },
    SendOpenTargetFlexibleEvent { responder: RunnerSendOpenTargetFlexibleEventResponder },
}

impl RunnerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_version(self) -> Option<(RunnerGetVersionResponder)> {
        if let RunnerRequest::GetVersion { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_check_alive(self) -> Option<(RunnerCheckAliveResponder)> {
        if let RunnerRequest::CheckAlive { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_start(self) -> Option<(Test, AnyTarget, RunnerStartResponder)> {
        if let RunnerRequest::Start { test, any_target, responder } = self {
            Some((test, any_target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_shutdown_with_epitaph(self) -> Option<(i32, RunnerShutdownWithEpitaphResponder)> {
        if let RunnerRequest::ShutdownWithEpitaph { epitaph_status, responder } = self {
            Some((epitaph_status, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_send_open_target_strict_event(
        self,
    ) -> Option<(RunnerSendOpenTargetStrictEventResponder)> {
        if let RunnerRequest::SendOpenTargetStrictEvent { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_send_open_target_flexible_event(
        self,
    ) -> Option<(RunnerSendOpenTargetFlexibleEventResponder)> {
        if let RunnerRequest::SendOpenTargetFlexibleEvent { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RunnerRequest::GetVersion { .. } => "get_version",
            RunnerRequest::CheckAlive { .. } => "check_alive",
            RunnerRequest::Start { .. } => "start",
            RunnerRequest::ShutdownWithEpitaph { .. } => "shutdown_with_epitaph",
            RunnerRequest::SendOpenTargetStrictEvent { .. } => "send_open_target_strict_event",
            RunnerRequest::SendOpenTargetFlexibleEvent { .. } => "send_open_target_flexible_event",
        }
    }
}

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

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

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

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

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

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

impl RunnerControlHandle {
    pub fn send_on_teardown(&self, mut reason: TeardownReason) -> Result<(), fidl::Error> {
        self.inner.send::<RunnerOnTeardownRequest>(
            (reason,),
            0,
            0x4472273866753acf,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_received_unknown_method(
        &self,
        mut ordinal: u64,
        mut unknown_method_type: UnknownMethodType,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<UnknownMethodInfo>(
            (ordinal, unknown_method_type),
            0,
            0x3c7f8d66a4f4c0e4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_received_closed_target_one_way_no_payload(&self) -> Result<(), fidl::Error> {
        self.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            0,
            0x56915f3fcde32b6f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_received_open_target_strict_one_way(&self) -> Result<(), fidl::Error> {
        self.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            0,
            0x5b82db8b0ffe97c5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_received_open_target_flexible_one_way(&self) -> Result<(), fidl::Error> {
        self.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            0,
            0x2428c34ecface889,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut version: u64) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RunnerGetVersionResponse>(
            (version,),
            self.tx_id,
            0x3c70bef2e59d06a7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

mod internal {
    use super::*;

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ClosedTargetCreateNHandleVectorRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { n: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect) }
        }

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ClosedTargetCreateNHandleVectorResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vec: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::UnboundedVector<
                    fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.vec,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ClosedTargetEchoAsTransferableSignalableEventRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ClosedTargetEchoAsTransferableSignalableEventResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 4098>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 4098>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.handle, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ClosedTargetGetHandleRightsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ClosedTargetGetSignalableEventRightsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 4096>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 4096>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.handle, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ClosedTargetHandleVectorSizeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vec: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::UnboundedVector<
                    fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.vec,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<RunnerStartRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut RunnerStartRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RunnerStartRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                RunnerStartRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <Test as fidl::encoding::ValueTypeMarker>::borrow(&self.test),
                    <AnyTarget as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.any_target,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<Test, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<AnyTarget, fidl::encoding::DefaultFuchsiaResourceDialect>,
    > fidl::encoding::Encode<RunnerStartRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RunnerStartRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RunnerStartRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                test: fidl::new_empty!(Test, fidl::encoding::DefaultFuchsiaResourceDialect),
                any_target: fidl::new_empty!(
                    AnyTarget,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                Test,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.test,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                AnyTarget,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.any_target,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl fidl::encoding::Encode<AnyTarget, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut AnyTarget
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AnyTarget>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            AnyTarget::Closed(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ClosedTargetMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ClosedTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            AnyTarget::Ajar(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AjarTargetMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AjarTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            AnyTarget::Open(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<OpenTargetMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<OpenTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
        }
        }
    }

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
            1 => <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ClosedTargetMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            2 => <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AjarTargetMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            3 => <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<OpenTargetMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            _ => return Err(fidl::Error::UnknownUnionTag),
        };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let AnyTarget::Closed(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = AnyTarget::Closed(fidl::new_empty!(
                            fidl::encoding::Endpoint<
                                fidl::endpoints::ServerEnd<ClosedTargetMarker>,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let AnyTarget::Closed(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Endpoint<
                                fidl::endpoints::ServerEnd<ClosedTargetMarker>,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let AnyTarget::Ajar(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = AnyTarget::Ajar(fidl::new_empty!(
                            fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AjarTargetMarker>>,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let AnyTarget::Ajar(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<AjarTargetMarker>>,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let AnyTarget::Open(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = AnyTarget::Open(fidl::new_empty!(
                            fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<OpenTargetMarker>>,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let AnyTarget::Open(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<OpenTargetMarker>>,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }
}