fidl_fidl_clientsuite/

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallFlexibleOneWayRequest {
    pub target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallFlexibleTwoWayErrRequest {
    pub target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallFlexibleTwoWayFieldsErrRequest {
    pub target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallFlexibleTwoWayFieldsRequest {
    pub target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallFlexibleTwoWayRequest {
    pub target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallOneWayNoRequestRequest {
    pub target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallOneWayStructRequestRequest {
    pub target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    pub request: NonEmptyPayload,
}

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

#[derive(Debug, PartialEq)]
pub struct RunnerCallOneWayTableRequestRequest {
    pub target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    pub request: TablePayload,
}

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

#[derive(Debug, PartialEq)]
pub struct RunnerCallOneWayUnionRequestRequest {
    pub target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    pub request: UnionPayload,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallStrictOneWayRequest {
    pub target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallStrictTwoWayErrRequest {
    pub target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallStrictTwoWayFieldsErrRequest {
    pub target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallStrictTwoWayFieldsRequest {
    pub target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallStrictTwoWayRequest {
    pub target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallTwoWayNoPayloadRequest {
    pub target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallTwoWayStructPayloadErrRequest {
    pub target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallTwoWayStructPayloadRequest {
    pub target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallTwoWayStructRequestRequest {
    pub target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    pub request: NonEmptyPayload,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallTwoWayTablePayloadRequest {
    pub target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct RunnerCallTwoWayTableRequestRequest {
    pub target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    pub request: TablePayload,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerCallTwoWayUnionPayloadRequest {
    pub target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct RunnerCallTwoWayUnionRequestRequest {
    pub target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    pub request: UnionPayload,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerReceiveAjarEventsRequest {
    pub target: fidl::endpoints::ClientEnd<AjarTargetMarker>,
    pub reporter: fidl::endpoints::ClientEnd<AjarTargetEventReporterMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerReceiveClosedEventsRequest {
    pub target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    pub reporter: fidl::endpoints::ClientEnd<ClosedTargetEventReporterMarker>,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerReceiveOpenEventsRequest {
    pub target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    pub reporter: fidl::endpoints::ClientEnd<OpenTargetEventReporterMarker>,
}

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

#[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 {
        let protocol_name = <AjarTargetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

#[cfg(target_os = "fuchsia")]
impl From<AjarTargetSynchronousProxy> for zx::Handle {
    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)
    }
}

#[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.clientsuite/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.clientsuite/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 fidl::endpoints::ControlHandle for AjarTargetControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl AjarTargetControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for AjarTargetEventReporterMarker {
    type Proxy = AjarTargetEventReporterProxy;
    type RequestStream = AjarTargetEventReporterRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AjarTargetEventReporterSynchronousProxy;

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AjarTargetEventReporterSynchronousProxy {
    type Proxy = AjarTargetEventReporterProxy;
    type Protocol = AjarTargetEventReporterMarker;

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

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

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

    pub fn r#report_event(&self, mut payload: &AjarTargetEventReport) -> Result<(), fidl::Error> {
        self.client.send::<AjarTargetEventReport>(
            payload,
            0x477b93390be99238,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

impl fidl::endpoints::Proxy for AjarTargetEventReporterProxy {
    type Protocol = AjarTargetEventReporterMarker;

    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 AjarTargetEventReporterProxy {
    /// Create a new Proxy for fidl.clientsuite/AjarTargetEventReporter.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <AjarTargetEventReporterMarker 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) -> AjarTargetEventReporterEventStream {
        AjarTargetEventReporterEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#report_event(&self, mut payload: &AjarTargetEventReport) -> Result<(), fidl::Error> {
        AjarTargetEventReporterProxyInterface::r#report_event(self, payload)
    }
}

impl AjarTargetEventReporterProxyInterface for AjarTargetEventReporterProxy {
    fn r#report_event(&self, mut payload: &AjarTargetEventReport) -> Result<(), fidl::Error> {
        self.client.send::<AjarTargetEventReport>(
            payload,
            0x477b93390be99238,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for AjarTargetEventReporterRequestStream {
    type Protocol = AjarTargetEventReporterMarker;
    type ControlHandle = AjarTargetEventReporterControlHandle;

    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 {
        AjarTargetEventReporterControlHandle { 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 AjarTargetEventReporterRequestStream {
    type Item = Result<AjarTargetEventReporterRequest, 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 AjarTargetEventReporterRequestStream 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 {
                0x477b93390be99238 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(AjarTargetEventReport, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AjarTargetEventReport>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = AjarTargetEventReporterControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(AjarTargetEventReporterRequest::ReportEvent {payload: req,
                        control_handle,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <AjarTargetEventReporterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

#[derive(Debug)]
pub enum AjarTargetEventReporterRequest {
    ReportEvent {
        payload: AjarTargetEventReport,
        control_handle: AjarTargetEventReporterControlHandle,
    },
}

impl AjarTargetEventReporterRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_report_event(
        self,
    ) -> Option<(AjarTargetEventReport, AjarTargetEventReporterControlHandle)> {
        if let AjarTargetEventReporterRequest::ReportEvent { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for AjarTargetEventReporterControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl AjarTargetEventReporterControlHandle {}

#[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 ClosedTargetTwoWayStructPayloadErrResult = Result<i32, i32>;

pub trait ClosedTargetProxyInterface: Send + Sync {
    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<i32, fidl::Error>>
        + Send;
    fn r#two_way_struct_payload(&self) -> Self::TwoWayStructPayloadResponseFut;
    type TwoWayTablePayloadResponseFut: std::future::Future<Output = Result<TablePayload, fidl::Error>>
        + Send;
    fn r#two_way_table_payload(&self) -> Self::TwoWayTablePayloadResponseFut;
    type TwoWayUnionPayloadResponseFut: std::future::Future<Output = Result<UnionPayload, fidl::Error>>
        + Send;
    fn r#two_way_union_payload(&self) -> Self::TwoWayUnionPayloadResponseFut;
    type TwoWayStructPayloadErrResponseFut: std::future::Future<Output = Result<ClosedTargetTwoWayStructPayloadErrResult, fidl::Error>>
        + Send;
    fn r#two_way_struct_payload_err(&self) -> Self::TwoWayStructPayloadErrResponseFut;
    type TwoWayStructRequestResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#two_way_struct_request(&self, some_field: i32) -> Self::TwoWayStructRequestResponseFut;
    type TwoWayTableRequestResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#two_way_table_request(
        &self,
        payload: &TablePayload,
    ) -> Self::TwoWayTableRequestResponseFut;
    type TwoWayUnionRequestResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#two_way_union_request(
        &self,
        payload: &UnionPayload,
    ) -> Self::TwoWayUnionRequestResponseFut;
    fn r#one_way_no_request(&self) -> Result<(), fidl::Error>;
    fn r#one_way_struct_request(&self, some_field: i32) -> Result<(), fidl::Error>;
    fn r#one_way_table_request(&self, payload: &TablePayload) -> Result<(), fidl::Error>;
    fn r#one_way_union_request(&self, payload: &UnionPayload) -> Result<(), fidl::Error>;
}
#[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 {
        let protocol_name = <ClosedTargetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    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>(
                (),
                0x7a722961424c1720,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

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

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

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

    pub fn r#two_way_struct_payload_err(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ClosedTargetTwoWayStructPayloadErrResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<NonEmptyPayload, i32>,
        >(
            (),
            0x62b4861c443bbc0b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.some_field))
    }

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

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

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

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

    pub fn r#one_way_struct_request(&self, mut some_field: i32) -> Result<(), fidl::Error> {
        self.client.send::<NonEmptyPayload>(
            (some_field,),
            0x2618da6f51e0dcd2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#one_way_table_request(&self, mut payload: &TablePayload) -> Result<(), fidl::Error> {
        self.client.send::<TablePayload>(
            payload,
            0x1a4b7d32eaed401f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn r#one_way_union_request(&self, mut payload: &UnionPayload) -> Result<(), fidl::Error> {
        self.client.send::<UnionPayload>(
            payload,
            0x142b3cd9ea530de5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[cfg(target_os = "fuchsia")]
impl From<ClosedTargetSynchronousProxy> for zx::Handle {
    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)
    }
}

#[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.clientsuite/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#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,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        ClosedTargetProxyInterface::r#two_way_struct_payload(self)
    }

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

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

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

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

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

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

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

    pub fn r#one_way_struct_request(&self, mut some_field: i32) -> Result<(), fidl::Error> {
        ClosedTargetProxyInterface::r#one_way_struct_request(self, some_field)
    }

    pub fn r#one_way_table_request(&self, mut payload: &TablePayload) -> Result<(), fidl::Error> {
        ClosedTargetProxyInterface::r#one_way_table_request(self, payload)
    }

    pub fn r#one_way_union_request(&self, mut payload: &UnionPayload) -> Result<(), fidl::Error> {
        ClosedTargetProxyInterface::r#one_way_union_request(self, payload)
    }
}

impl ClosedTargetProxyInterface for ClosedTargetProxy {
    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,
                0x7a722961424c1720,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x7a722961424c1720,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type TwoWayStructPayloadResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#two_way_struct_payload(&self) -> Self::TwoWayStructPayloadResponseFut {
        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::<
                NonEmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3a402118bad781bd,
            >(_buf?)?;
            Ok(_response.some_field)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
            (),
            0x3a402118bad781bd,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

    type TwoWayStructPayloadErrResponseFut = fidl::client::QueryResponseFut<
        ClosedTargetTwoWayStructPayloadErrResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#two_way_struct_payload_err(&self) -> Self::TwoWayStructPayloadErrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ClosedTargetTwoWayStructPayloadErrResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<NonEmptyPayload, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x62b4861c443bbc0b,
            >(_buf?)?;
            Ok(_response.map(|x| x.some_field))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            ClosedTargetTwoWayStructPayloadErrResult,
        >(
            (),
            0x62b4861c443bbc0b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type TwoWayStructRequestResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#two_way_struct_request(
        &self,
        mut some_field: i32,
    ) -> Self::TwoWayStructRequestResponseFut {
        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,
                0x4ff77b4a913be5b6,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<NonEmptyPayload, ()>(
            (some_field,),
            0x4ff77b4a913be5b6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type TwoWayTableRequestResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#two_way_table_request(
        &self,
        mut payload: &TablePayload,
    ) -> Self::TwoWayTableRequestResponseFut {
        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,
                0x3d38ad5b0f4f49cf,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<TablePayload, ()>(
            payload,
            0x3d38ad5b0f4f49cf,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type TwoWayUnionRequestResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#two_way_union_request(
        &self,
        mut payload: &UnionPayload,
    ) -> Self::TwoWayUnionRequestResponseFut {
        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,
                0x7adb1c265a378e77,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<UnionPayload, ()>(
            payload,
            0x7adb1c265a378e77,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    fn r#one_way_struct_request(&self, mut some_field: i32) -> Result<(), fidl::Error> {
        self.client.send::<NonEmptyPayload>(
            (some_field,),
            0x2618da6f51e0dcd2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#one_way_table_request(&self, mut payload: &TablePayload) -> Result<(), fidl::Error> {
        self.client.send::<TablePayload>(
            payload,
            0x1a4b7d32eaed401f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#one_way_union_request(&self, mut payload: &UnionPayload) -> Result<(), fidl::Error> {
        self.client.send::<UnionPayload>(
            payload,
            0x142b3cd9ea530de5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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 {
    OnEventNoPayload {},
    OnEventStructPayload { some_field: i32 },
    OnEventTablePayload { payload: TablePayload },
    OnEventUnionPayload { payload: UnionPayload },
}

impl ClosedTargetEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_event_no_payload(self) -> Option<()> {
        if let ClosedTargetEvent::OnEventNoPayload {} = self {
            Some(())
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_event_struct_payload(self) -> Option<i32> {
        if let ClosedTargetEvent::OnEventStructPayload { some_field } = self {
            Some((some_field))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_event_table_payload(self) -> Option<TablePayload> {
        if let ClosedTargetEvent::OnEventTablePayload { payload } = self {
            Some((payload))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_event_union_payload(self) -> Option<UnionPayload> {
        if let ClosedTargetEvent::OnEventUnionPayload { payload } = self {
            Some((payload))
        } else {
            None
        }
    }

    /// 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 {
            0x4ee7b8d3e6bb36a6 => {
                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((ClosedTargetEvent::OnEventNoPayload {}))
            }
            0x48e8c897893ae266 => {
                let mut out = fidl::new_empty!(
                    NonEmptyPayload,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NonEmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((ClosedTargetEvent::OnEventStructPayload { some_field: out.some_field }))
            }
            0x72837525f4f3e746 => {
                let mut out =
                    fidl::new_empty!(TablePayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TablePayload>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((ClosedTargetEvent::OnEventTablePayload { payload: out }))
            }
            0x69c6390e1ac48ea0 => {
                let mut out =
                    fidl::new_empty!(UnionPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnionPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((ClosedTargetEvent::OnEventUnionPayload { payload: out }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <ClosedTargetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fidl.clientsuite/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 {
                    0x7a722961424c1720 => {
                        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,
                            },
                        })
                    }
                    0x3a402118bad781bd => {
                        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::TwoWayStructPayload {
                            responder: ClosedTargetTwoWayStructPayloadResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x53be101c241c66bc => {
                        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::TwoWayTablePayload {
                            responder: ClosedTargetTwoWayTablePayloadResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ff7f745ab608f8c => {
                        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::TwoWayUnionPayload {
                            responder: ClosedTargetTwoWayUnionPayloadResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x62b4861c443bbc0b => {
                        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::TwoWayStructPayloadErr {
                            responder: ClosedTargetTwoWayStructPayloadErrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4ff77b4a913be5b6 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            NonEmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NonEmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::TwoWayStructRequest {
                            some_field: req.some_field,

                            responder: ClosedTargetTwoWayStructRequestResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3d38ad5b0f4f49cf => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            TablePayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TablePayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::TwoWayTableRequest {
                            payload: req,
                            responder: ClosedTargetTwoWayTableRequestResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7adb1c265a378e77 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            UnionPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnionPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::TwoWayUnionRequest {
                            payload: req,
                            responder: ClosedTargetTwoWayUnionRequestResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xc376730a2cd8a05 => {
                        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::OneWayNoRequest { control_handle })
                    }
                    0x2618da6f51e0dcd2 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            NonEmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NonEmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::OneWayStructRequest {
                            some_field: req.some_field,

                            control_handle,
                        })
                    }
                    0x1a4b7d32eaed401f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            TablePayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TablePayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::OneWayTableRequest { payload: req, control_handle })
                    }
                    0x142b3cd9ea530de5 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            UnionPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnionPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ClosedTargetControlHandle { inner: this.inner.clone() };
                        Ok(ClosedTargetRequest::OneWayUnionRequest { payload: req, control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ClosedTargetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum ClosedTargetRequest {
    TwoWayNoPayload { responder: ClosedTargetTwoWayNoPayloadResponder },
    TwoWayStructPayload { responder: ClosedTargetTwoWayStructPayloadResponder },
    TwoWayTablePayload { responder: ClosedTargetTwoWayTablePayloadResponder },
    TwoWayUnionPayload { responder: ClosedTargetTwoWayUnionPayloadResponder },
    TwoWayStructPayloadErr { responder: ClosedTargetTwoWayStructPayloadErrResponder },
    TwoWayStructRequest { some_field: i32, responder: ClosedTargetTwoWayStructRequestResponder },
    TwoWayTableRequest { payload: TablePayload, responder: ClosedTargetTwoWayTableRequestResponder },
    TwoWayUnionRequest { payload: UnionPayload, responder: ClosedTargetTwoWayUnionRequestResponder },
    OneWayNoRequest { control_handle: ClosedTargetControlHandle },
    OneWayStructRequest { some_field: i32, control_handle: ClosedTargetControlHandle },
    OneWayTableRequest { payload: TablePayload, control_handle: ClosedTargetControlHandle },
    OneWayUnionRequest { payload: UnionPayload, control_handle: ClosedTargetControlHandle },
}

impl ClosedTargetRequest {
    #[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<(ClosedTargetTwoWayStructPayloadResponder)> {
        if let ClosedTargetRequest::TwoWayStructPayload { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_two_way_struct_payload_err(
        self,
    ) -> Option<(ClosedTargetTwoWayStructPayloadErrResponder)> {
        if let ClosedTargetRequest::TwoWayStructPayloadErr { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_two_way_struct_request(
        self,
    ) -> Option<(i32, ClosedTargetTwoWayStructRequestResponder)> {
        if let ClosedTargetRequest::TwoWayStructRequest { some_field, responder } = self {
            Some((some_field, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_two_way_table_request(
        self,
    ) -> Option<(TablePayload, ClosedTargetTwoWayTableRequestResponder)> {
        if let ClosedTargetRequest::TwoWayTableRequest { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_two_way_union_request(
        self,
    ) -> Option<(UnionPayload, ClosedTargetTwoWayUnionRequestResponder)> {
        if let ClosedTargetRequest::TwoWayUnionRequest { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_one_way_struct_request(self) -> Option<(i32, ClosedTargetControlHandle)> {
        if let ClosedTargetRequest::OneWayStructRequest { some_field, control_handle } = self {
            Some((some_field, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_one_way_table_request(self) -> Option<(TablePayload, ClosedTargetControlHandle)> {
        if let ClosedTargetRequest::OneWayTableRequest { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_one_way_union_request(self) -> Option<(UnionPayload, ClosedTargetControlHandle)> {
        if let ClosedTargetRequest::OneWayUnionRequest { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            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::TwoWayStructPayloadErr { .. } => "two_way_struct_payload_err",
            ClosedTargetRequest::TwoWayStructRequest { .. } => "two_way_struct_request",
            ClosedTargetRequest::TwoWayTableRequest { .. } => "two_way_table_request",
            ClosedTargetRequest::TwoWayUnionRequest { .. } => "two_way_union_request",
            ClosedTargetRequest::OneWayNoRequest { .. } => "one_way_no_request",
            ClosedTargetRequest::OneWayStructRequest { .. } => "one_way_struct_request",
            ClosedTargetRequest::OneWayTableRequest { .. } => "one_way_table_request",
            ClosedTargetRequest::OneWayUnionRequest { .. } => "one_way_union_request",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for ClosedTargetControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

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

    pub fn send_on_event_struct_payload(&self, mut some_field: i32) -> Result<(), fidl::Error> {
        self.inner.send::<NonEmptyPayload>(
            (some_field,),
            0,
            0x48e8c897893ae266,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_event_table_payload(
        &self,
        mut payload: &TablePayload,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<TablePayload>(
            payload,
            0,
            0x72837525f4f3e746,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_event_union_payload(
        &self,
        mut payload: &UnionPayload,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<UnionPayload>(
            payload,
            0,
            0x69c6390e1ac48ea0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[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,
            0x7a722961424c1720,
            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 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::<NonEmptyPayload>(
            (some_field,),
            self.tx_id,
            0x3a402118bad781bd,
            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: &TablePayload) -> 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: &TablePayload) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut payload: &TablePayload) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<TablePayload>(
            payload,
            self.tx_id,
            0x53be101c241c66bc,
            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: &UnionPayload) -> 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: &UnionPayload) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        self.drop_without_shutdown();
        _result
    }

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ClosedTargetTwoWayStructPayloadErrResponder {
    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 ClosedTargetTwoWayStructPayloadErrResponder {
    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 ClosedTargetTwoWayStructPayloadErrResponder {
    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 ClosedTargetTwoWayStructPayloadErrResponder {
    /// 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<NonEmptyPayload, i32>>(
            result.map(|some_field| (some_field,)),
            self.tx_id,
            0x62b4861c443bbc0b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ClosedTargetTwoWayStructRequestResponder {
    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 ClosedTargetTwoWayStructRequestResponder {
    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 ClosedTargetTwoWayStructRequestResponder {
    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 ClosedTargetTwoWayStructRequestResponder {
    /// 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,
            0x4ff77b4a913be5b6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ClosedTargetTwoWayTableRequestResponder {
    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 ClosedTargetTwoWayTableRequestResponder {
    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 ClosedTargetTwoWayTableRequestResponder {
    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 ClosedTargetTwoWayTableRequestResponder {
    /// 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,
            0x3d38ad5b0f4f49cf,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ClosedTargetTwoWayUnionRequestResponder {
    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 ClosedTargetTwoWayUnionRequestResponder {
    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 ClosedTargetTwoWayUnionRequestResponder {
    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 ClosedTargetTwoWayUnionRequestResponder {
    /// 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,
            0x7adb1c265a378e77,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for ClosedTargetEventReporterMarker {
    type Proxy = ClosedTargetEventReporterProxy;
    type RequestStream = ClosedTargetEventReporterRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ClosedTargetEventReporterSynchronousProxy;

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ClosedTargetEventReporterSynchronousProxy {
    type Proxy = ClosedTargetEventReporterProxy;
    type Protocol = ClosedTargetEventReporterMarker;

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

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

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

    pub fn r#report_event(&self, mut payload: &ClosedTargetEventReport) -> Result<(), fidl::Error> {
        self.client.send::<ClosedTargetEventReport>(
            payload,
            0x63890e67649a846e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

impl fidl::endpoints::Proxy for ClosedTargetEventReporterProxy {
    type Protocol = ClosedTargetEventReporterMarker;

    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 ClosedTargetEventReporterProxy {
    /// Create a new Proxy for fidl.clientsuite/ClosedTargetEventReporter.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <ClosedTargetEventReporterMarker 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) -> ClosedTargetEventReporterEventStream {
        ClosedTargetEventReporterEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#report_event(&self, mut payload: &ClosedTargetEventReport) -> Result<(), fidl::Error> {
        ClosedTargetEventReporterProxyInterface::r#report_event(self, payload)
    }
}

impl ClosedTargetEventReporterProxyInterface for ClosedTargetEventReporterProxy {
    fn r#report_event(&self, mut payload: &ClosedTargetEventReport) -> Result<(), fidl::Error> {
        self.client.send::<ClosedTargetEventReport>(
            payload,
            0x63890e67649a846e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ClosedTargetEventReporterRequestStream {
    type Protocol = ClosedTargetEventReporterMarker;
    type ControlHandle = ClosedTargetEventReporterControlHandle;

    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 {
        ClosedTargetEventReporterControlHandle { 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 ClosedTargetEventReporterRequestStream {
    type Item = Result<ClosedTargetEventReporterRequest, 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 ClosedTargetEventReporterRequestStream 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 {
                0x63890e67649a846e => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(ClosedTargetEventReport, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ClosedTargetEventReport>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = ClosedTargetEventReporterControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ClosedTargetEventReporterRequest::ReportEvent {payload: req,
                        control_handle,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <ClosedTargetEventReporterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

#[derive(Debug)]
pub enum ClosedTargetEventReporterRequest {
    ReportEvent {
        payload: ClosedTargetEventReport,
        control_handle: ClosedTargetEventReporterControlHandle,
    },
}

impl ClosedTargetEventReporterRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_report_event(
        self,
    ) -> Option<(ClosedTargetEventReport, ClosedTargetEventReporterControlHandle)> {
        if let ClosedTargetEventReporterRequest::ReportEvent { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for ClosedTargetEventReporterControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl ClosedTargetEventReporterControlHandle {}

#[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) -> Self::StrictTwoWayFieldsResponseFut;
    type StrictTwoWayErrResponseFut: std::future::Future<Output = Result<OpenTargetStrictTwoWayErrResult, fidl::Error>>
        + Send;
    fn r#strict_two_way_err(&self) -> Self::StrictTwoWayErrResponseFut;
    type StrictTwoWayFieldsErrResponseFut: std::future::Future<Output = Result<OpenTargetStrictTwoWayFieldsErrResult, fidl::Error>>
        + Send;
    fn r#strict_two_way_fields_err(&self) -> 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) -> Self::FlexibleTwoWayFieldsResponseFut;
    type FlexibleTwoWayErrResponseFut: std::future::Future<Output = Result<OpenTargetFlexibleTwoWayErrResult, fidl::Error>>
        + Send;
    fn r#flexible_two_way_err(&self) -> Self::FlexibleTwoWayErrResponseFut;
    type FlexibleTwoWayFieldsErrResponseFut: std::future::Future<Output = Result<OpenTargetFlexibleTwoWayFieldsErrResult, fidl::Error>>
        + Send;
    fn r#flexible_two_way_fields_err(&self) -> 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 {
        let protocol_name = <OpenTargetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

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

    pub fn r#flexible_one_way(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0xf894a7eb9cc29fc,
            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>(
                (),
                0xdcf4cef19a1c542,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

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

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

    pub fn r#strict_two_way_fields_err(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<OpenTargetStrictTwoWayFieldsErrResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<NonEmptyPayload, i32>,
        >(
            (),
            0x7dbaa8538b552711,
            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>,
        >(
            (),
            0x66552e68b99a0587,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            ___deadline,
        )?
        .into_result::<OpenTargetMarker>("flexible_two_way")?;
        Ok(_response)
    }

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

    pub fn r#flexible_two_way_err(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<OpenTargetFlexibleTwoWayErrResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x6e144c6e0cf2147a,
            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,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<OpenTargetFlexibleTwoWayFieldsErrResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::FlexibleResultType<NonEmptyPayload, i32>,
        >(
            (),
            0xe494147cda8024a,
            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::Handle {
    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)
    }
}

#[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.clientsuite/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,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        OpenTargetProxyInterface::r#strict_two_way_fields(self)
    }

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

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

    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,
    ) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
        OpenTargetProxyInterface::r#flexible_two_way_fields(self)
    }

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

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

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

    fn r#flexible_one_way(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0xf894a7eb9cc29fc,
            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,
                0xdcf4cef19a1c542,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0xdcf4cef19a1c542,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StrictTwoWayFieldsResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#strict_two_way_fields(&self) -> 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::<
                NonEmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x79c7a7803c45e2e3,
            >(_buf?)?;
            Ok(_response.some_field)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
            (),
            0x79c7a7803c45e2e3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StrictTwoWayErrResponseFut = fidl::client::QueryResponseFut<
        OpenTargetStrictTwoWayErrResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#strict_two_way_err(&self) -> 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,
                0x54259ed6c262fe88,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, OpenTargetStrictTwoWayErrResult>(
                (),
                0x54259ed6c262fe88,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type StrictTwoWayFieldsErrResponseFut = fidl::client::QueryResponseFut<
        OpenTargetStrictTwoWayFieldsErrResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#strict_two_way_fields_err(&self) -> 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<NonEmptyPayload, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7dbaa8538b552711,
            >(_buf?)?;
            Ok(_response.map(|x| x.some_field))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            OpenTargetStrictTwoWayFieldsErrResult,
        >(
            (),
            0x7dbaa8538b552711,
            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,
                0x66552e68b99a0587,
            >(_buf?)?
            .into_result::<OpenTargetMarker>("flexible_two_way")?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x66552e68b99a0587,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type FlexibleTwoWayFieldsResponseFut =
        fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#flexible_two_way_fields(&self) -> 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<NonEmptyPayload>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x38b95648ac4e2ae4,
            >(_buf?)?
            .into_result::<OpenTargetMarker>("flexible_two_way_fields")?;
            Ok(_response.some_field)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
            (),
            0x38b95648ac4e2ae4,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type FlexibleTwoWayErrResponseFut = fidl::client::QueryResponseFut<
        OpenTargetFlexibleTwoWayErrResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#flexible_two_way_err(&self) -> 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,
                0x6e144c6e0cf2147a,
            >(_buf?)?
            .into_result::<OpenTargetMarker>("flexible_two_way_err")?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            OpenTargetFlexibleTwoWayErrResult,
        >(
            (),
            0x6e144c6e0cf2147a,
            fidl::encoding::DynamicFlags::FLEXIBLE,
            _decode,
        )
    }

    type FlexibleTwoWayFieldsErrResponseFut = fidl::client::QueryResponseFut<
        OpenTargetFlexibleTwoWayFieldsErrResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#flexible_two_way_fields_err(&self) -> 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<NonEmptyPayload, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xe494147cda8024a,
            >(_buf?)?
            .into_result::<OpenTargetMarker>("flexible_two_way_fields_err")?;
            Ok(_response.map(|x| x.some_field))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            OpenTargetFlexibleTwoWayFieldsErrResult,
        >(
            (),
            0xe494147cda8024a,
            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 {
            0x2b291d74321e77a0 => {
                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 {}))
            }
            0x50d4688058898898 => {
                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.clientsuite/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 {
                    0x6db0bc21c4aae764 => {
                        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 })
                    }
                    0xf894a7eb9cc29fc => {
                        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 })
                    }
                    0xdcf4cef19a1c542 => {
                        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,
                            },
                        })
                    }
                    0x79c7a7803c45e2e3 => {
                        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::StrictTwoWayFields {
                            responder: OpenTargetStrictTwoWayFieldsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x54259ed6c262fe88 => {
                        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::StrictTwoWayErr {
                            responder: OpenTargetStrictTwoWayErrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7dbaa8538b552711 => {
                        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::StrictTwoWayFieldsErr {
                            responder: OpenTargetStrictTwoWayFieldsErrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x66552e68b99a0587 => {
                        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,
                            },
                        })
                    }
                    0x38b95648ac4e2ae4 => {
                        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::FlexibleTwoWayFields {
                            responder: OpenTargetFlexibleTwoWayFieldsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e144c6e0cf2147a => {
                        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::FlexibleTwoWayErr {
                            responder: OpenTargetFlexibleTwoWayErrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xe494147cda8024a => {
                        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::FlexibleTwoWayFieldsErr {
                            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 {
        responder: OpenTargetStrictTwoWayFieldsResponder,
    },
    StrictTwoWayErr {
        responder: OpenTargetStrictTwoWayErrResponder,
    },
    StrictTwoWayFieldsErr {
        responder: OpenTargetStrictTwoWayFieldsErrResponder,
    },
    FlexibleTwoWay {
        responder: OpenTargetFlexibleTwoWayResponder,
    },
    FlexibleTwoWayFields {
        responder: OpenTargetFlexibleTwoWayFieldsResponder,
    },
    FlexibleTwoWayErr {
        responder: OpenTargetFlexibleTwoWayErrResponder,
    },
    FlexibleTwoWayFieldsErr {
        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<(OpenTargetStrictTwoWayFieldsResponder)> {
        if let OpenTargetRequest::StrictTwoWayFields { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_strict_two_way_fields_err(
        self,
    ) -> Option<(OpenTargetStrictTwoWayFieldsErrResponder)> {
        if let OpenTargetRequest::StrictTwoWayFieldsErr { responder } = self {
            Some((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<(OpenTargetFlexibleTwoWayFieldsResponder)> {
        if let OpenTargetRequest::FlexibleTwoWayFields { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

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

    #[allow(irrefutable_let_patterns)]
    pub fn into_flexible_two_way_fields_err(
        self,
    ) -> Option<(OpenTargetFlexibleTwoWayFieldsErrResponder)> {
        if let OpenTargetRequest::FlexibleTwoWayFieldsErr { responder } = self {
            Some((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 fidl::endpoints::ControlHandle for OpenTargetControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

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

    pub fn send_flexible_event(&self) -> Result<(), fidl::Error> {
        self.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            0,
            0x50d4688058898898,
            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,
            0xdcf4cef19a1c542,
            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::<NonEmptyPayload>(
            (some_field,),
            self.tx_id,
            0x79c7a7803c45e2e3,
            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,
                0x54259ed6c262fe88,
                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<NonEmptyPayload, i32>>(
            result.map(|some_field| (some_field,)),
            self.tx_id,
            0x7dbaa8538b552711,
            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,
            0x66552e68b99a0587,
            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<NonEmptyPayload>>(
            fidl::encoding::Flexible::new((some_field,)),
            self.tx_id,
            0x38b95648ac4e2ae4,
            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,
            0x6e144c6e0cf2147a,
            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<NonEmptyPayload, i32>>(
            fidl::encoding::FlexibleResult::new(result.map(|some_field| (some_field,))),
            self.tx_id,
            0xe494147cda8024a,
            fidl::encoding::DynamicFlags::FLEXIBLE,
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for OpenTargetEventReporterMarker {
    type Proxy = OpenTargetEventReporterProxy;
    type RequestStream = OpenTargetEventReporterRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = OpenTargetEventReporterSynchronousProxy;

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

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

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for OpenTargetEventReporterSynchronousProxy {
    type Proxy = OpenTargetEventReporterProxy;
    type Protocol = OpenTargetEventReporterMarker;

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

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

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

    pub fn r#report_event(&self, mut payload: &OpenTargetEventReport) -> Result<(), fidl::Error> {
        self.client.send::<OpenTargetEventReport>(
            payload,
            0x70ab38ec0248964a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

impl fidl::endpoints::Proxy for OpenTargetEventReporterProxy {
    type Protocol = OpenTargetEventReporterMarker;

    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 OpenTargetEventReporterProxy {
    /// Create a new Proxy for fidl.clientsuite/OpenTargetEventReporter.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <OpenTargetEventReporterMarker 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) -> OpenTargetEventReporterEventStream {
        OpenTargetEventReporterEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#report_event(&self, mut payload: &OpenTargetEventReport) -> Result<(), fidl::Error> {
        OpenTargetEventReporterProxyInterface::r#report_event(self, payload)
    }
}

impl OpenTargetEventReporterProxyInterface for OpenTargetEventReporterProxy {
    fn r#report_event(&self, mut payload: &OpenTargetEventReport) -> Result<(), fidl::Error> {
        self.client.send::<OpenTargetEventReport>(
            payload,
            0x70ab38ec0248964a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for OpenTargetEventReporterRequestStream {
    type Protocol = OpenTargetEventReporterMarker;
    type ControlHandle = OpenTargetEventReporterControlHandle;

    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 {
        OpenTargetEventReporterControlHandle { 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 OpenTargetEventReporterRequestStream {
    type Item = Result<OpenTargetEventReporterRequest, 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 OpenTargetEventReporterRequestStream 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 {
                0x70ab38ec0248964a => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(OpenTargetEventReport, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<OpenTargetEventReport>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = OpenTargetEventReporterControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(OpenTargetEventReporterRequest::ReportEvent {payload: req,
                        control_handle,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <OpenTargetEventReporterMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

#[derive(Debug)]
pub enum OpenTargetEventReporterRequest {
    ReportEvent {
        payload: OpenTargetEventReport,
        control_handle: OpenTargetEventReporterControlHandle,
    },
}

impl OpenTargetEventReporterRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_report_event(
        self,
    ) -> Option<(OpenTargetEventReport, OpenTargetEventReporterControlHandle)> {
        if let OpenTargetEventReporterRequest::ReportEvent { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

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

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

impl fidl::endpoints::ControlHandle for OpenTargetEventReporterControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl OpenTargetEventReporterControlHandle {}

#[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.clientsuite.Runner";
}
impl fidl::endpoints::DiscoverableProtocolMarker for RunnerMarker {}

pub trait RunnerProxyInterface: Send + Sync {
    type GetVersionResponseFut: std::future::Future<Output = Result<u64, fidl::Error>> + Send;
    fn r#get_version(&self) -> Self::GetVersionResponseFut;
    type IsTestEnabledResponseFut: std::future::Future<Output = Result<bool, fidl::Error>> + Send;
    fn r#is_test_enabled(&self, test: Test) -> Self::IsTestEnabledResponseFut;
    type CheckAliveResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#check_alive(&self) -> Self::CheckAliveResponseFut;
    type GetBindingsPropertiesResponseFut: std::future::Future<Output = Result<BindingsProperties, fidl::Error>>
        + Send;
    fn r#get_bindings_properties(&self) -> Self::GetBindingsPropertiesResponseFut;
    type CallTwoWayNoPayloadResponseFut: std::future::Future<Output = Result<EmptyResultClassification, fidl::Error>>
        + Send;
    fn r#call_two_way_no_payload(
        &self,
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> Self::CallTwoWayNoPayloadResponseFut;
    type CallTwoWayStructPayloadResponseFut: std::future::Future<Output = Result<NonEmptyResultClassification, fidl::Error>>
        + Send;
    fn r#call_two_way_struct_payload(
        &self,
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> Self::CallTwoWayStructPayloadResponseFut;
    type CallTwoWayTablePayloadResponseFut: std::future::Future<Output = Result<TableResultClassification, fidl::Error>>
        + Send;
    fn r#call_two_way_table_payload(
        &self,
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> Self::CallTwoWayTablePayloadResponseFut;
    type CallTwoWayUnionPayloadResponseFut: std::future::Future<Output = Result<UnionResultClassification, fidl::Error>>
        + Send;
    fn r#call_two_way_union_payload(
        &self,
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> Self::CallTwoWayUnionPayloadResponseFut;
    type CallTwoWayStructPayloadErrResponseFut: std::future::Future<Output = Result<NonEmptyResultWithErrorClassification, fidl::Error>>
        + Send;
    fn r#call_two_way_struct_payload_err(
        &self,
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> Self::CallTwoWayStructPayloadErrResponseFut;
    type CallTwoWayStructRequestResponseFut: std::future::Future<Output = Result<EmptyResultClassification, fidl::Error>>
        + Send;
    fn r#call_two_way_struct_request(
        &self,
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        request: &NonEmptyPayload,
    ) -> Self::CallTwoWayStructRequestResponseFut;
    type CallTwoWayTableRequestResponseFut: std::future::Future<Output = Result<EmptyResultClassification, fidl::Error>>
        + Send;
    fn r#call_two_way_table_request(
        &self,
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        request: &TablePayload,
    ) -> Self::CallTwoWayTableRequestResponseFut;
    type CallTwoWayUnionRequestResponseFut: std::future::Future<Output = Result<EmptyResultClassification, fidl::Error>>
        + Send;
    fn r#call_two_way_union_request(
        &self,
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        request: &UnionPayload,
    ) -> Self::CallTwoWayUnionRequestResponseFut;
    type CallOneWayNoRequestResponseFut: std::future::Future<Output = Result<EmptyResultClassification, fidl::Error>>
        + Send;
    fn r#call_one_way_no_request(
        &self,
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> Self::CallOneWayNoRequestResponseFut;
    type CallOneWayStructRequestResponseFut: std::future::Future<Output = Result<EmptyResultClassification, fidl::Error>>
        + Send;
    fn r#call_one_way_struct_request(
        &self,
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        request: &NonEmptyPayload,
    ) -> Self::CallOneWayStructRequestResponseFut;
    type CallOneWayTableRequestResponseFut: std::future::Future<Output = Result<EmptyResultClassification, fidl::Error>>
        + Send;
    fn r#call_one_way_table_request(
        &self,
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        request: &TablePayload,
    ) -> Self::CallOneWayTableRequestResponseFut;
    type CallOneWayUnionRequestResponseFut: std::future::Future<Output = Result<EmptyResultClassification, fidl::Error>>
        + Send;
    fn r#call_one_way_union_request(
        &self,
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        request: &UnionPayload,
    ) -> Self::CallOneWayUnionRequestResponseFut;
    type CallStrictOneWayResponseFut: std::future::Future<Output = Result<EmptyResultClassification, fidl::Error>>
        + Send;
    fn r#call_strict_one_way(
        &self,
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallStrictOneWayResponseFut;
    type CallFlexibleOneWayResponseFut: std::future::Future<Output = Result<EmptyResultClassification, fidl::Error>>
        + Send;
    fn r#call_flexible_one_way(
        &self,
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallFlexibleOneWayResponseFut;
    type CallStrictTwoWayResponseFut: std::future::Future<Output = Result<EmptyResultClassification, fidl::Error>>
        + Send;
    fn r#call_strict_two_way(
        &self,
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallStrictTwoWayResponseFut;
    type CallStrictTwoWayFieldsResponseFut: std::future::Future<Output = Result<NonEmptyResultClassification, fidl::Error>>
        + Send;
    fn r#call_strict_two_way_fields(
        &self,
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallStrictTwoWayFieldsResponseFut;
    type CallStrictTwoWayErrResponseFut: std::future::Future<Output = Result<EmptyResultWithErrorClassification, fidl::Error>>
        + Send;
    fn r#call_strict_two_way_err(
        &self,
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallStrictTwoWayErrResponseFut;
    type CallStrictTwoWayFieldsErrResponseFut: std::future::Future<Output = Result<NonEmptyResultWithErrorClassification, fidl::Error>>
        + Send;
    fn r#call_strict_two_way_fields_err(
        &self,
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallStrictTwoWayFieldsErrResponseFut;
    type CallFlexibleTwoWayResponseFut: std::future::Future<Output = Result<EmptyResultClassification, fidl::Error>>
        + Send;
    fn r#call_flexible_two_way(
        &self,
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallFlexibleTwoWayResponseFut;
    type CallFlexibleTwoWayFieldsResponseFut: std::future::Future<Output = Result<NonEmptyResultClassification, fidl::Error>>
        + Send;
    fn r#call_flexible_two_way_fields(
        &self,
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallFlexibleTwoWayFieldsResponseFut;
    type CallFlexibleTwoWayErrResponseFut: std::future::Future<Output = Result<EmptyResultWithErrorClassification, fidl::Error>>
        + Send;
    fn r#call_flexible_two_way_err(
        &self,
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallFlexibleTwoWayErrResponseFut;
    type CallFlexibleTwoWayFieldsErrResponseFut: std::future::Future<Output = Result<NonEmptyResultWithErrorClassification, fidl::Error>>
        + Send;
    fn r#call_flexible_two_way_fields_err(
        &self,
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallFlexibleTwoWayFieldsErrResponseFut;
    type ReceiveClosedEventsResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#receive_closed_events(
        &self,
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        reporter: fidl::endpoints::ClientEnd<ClosedTargetEventReporterMarker>,
    ) -> Self::ReceiveClosedEventsResponseFut;
    type ReceiveAjarEventsResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#receive_ajar_events(
        &self,
        target: fidl::endpoints::ClientEnd<AjarTargetMarker>,
        reporter: fidl::endpoints::ClientEnd<AjarTargetEventReporterMarker>,
    ) -> Self::ReceiveAjarEventsResponseFut;
    type ReceiveOpenEventsResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#receive_open_events(
        &self,
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        reporter: fidl::endpoints::ClientEnd<OpenTargetEventReporterMarker>,
    ) -> Self::ReceiveOpenEventsResponseFut;
}
#[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 {
        let protocol_name = <RunnerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

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

    pub fn r#is_test_enabled(
        &self,
        mut test: Test,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<bool, fidl::Error> {
        let _response =
            self.client.send_query::<RunnerIsTestEnabledRequest, RunnerIsTestEnabledResponse>(
                (test,),
                0x755bc493368d7c50,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.is_enabled)
    }

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

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

    pub fn r#call_two_way_no_payload(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmptyResultClassification, fidl::Error> {
        let _response =
            self.client.send_query::<RunnerCallTwoWayNoPayloadRequest, EmptyResultClassification>(
                (target,),
                0x53ac710c20b320a1,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_two_way_struct_payload(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NonEmptyResultClassification, fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerCallTwoWayStructPayloadRequest, NonEmptyResultClassification>(
                (target,),
                0x24e98c668499b946,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_two_way_table_payload(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<TableResultClassification, fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerCallTwoWayTablePayloadRequest, TableResultClassification>(
                (target,),
                0x72e428e1605b76a,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_two_way_union_payload(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<UnionResultClassification, fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerCallTwoWayUnionPayloadRequest, UnionResultClassification>(
                (target,),
                0x7dc9d67218343860,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_two_way_struct_payload_err(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NonEmptyResultWithErrorClassification, fidl::Error> {
        let _response = self.client.send_query::<
            RunnerCallTwoWayStructPayloadErrRequest,
            NonEmptyResultWithErrorClassification,
        >(
            (target,),
            0x2b07a57942c5f6e5,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    pub fn r#call_two_way_struct_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &NonEmptyPayload,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmptyResultClassification, fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerCallTwoWayStructRequestRequest, EmptyResultClassification>(
                (target, request),
                0x7c00a6ba2e6c9b45,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_two_way_table_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &TablePayload,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmptyResultClassification, fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerCallTwoWayTableRequestRequest, EmptyResultClassification>(
                (target, request),
                0x641763237d3885be,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_two_way_union_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &UnionPayload,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmptyResultClassification, fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerCallTwoWayUnionRequestRequest, EmptyResultClassification>(
                (target, request),
                0x4be5f061df42619e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_one_way_no_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmptyResultClassification, fidl::Error> {
        let _response =
            self.client.send_query::<RunnerCallOneWayNoRequestRequest, EmptyResultClassification>(
                (target,),
                0x24b6eea8cbdccc09,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_one_way_struct_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &NonEmptyPayload,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmptyResultClassification, fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerCallOneWayStructRequestRequest, EmptyResultClassification>(
                (target, request),
                0x352a2907a0fcb420,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_one_way_table_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &TablePayload,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmptyResultClassification, fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerCallOneWayTableRequestRequest, EmptyResultClassification>(
                (target, request),
                0x734121bf8bf336ef,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_one_way_union_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &UnionPayload,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmptyResultClassification, fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerCallOneWayUnionRequestRequest, EmptyResultClassification>(
                (target, request),
                0x9be8e5eb7d50eb6,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_strict_one_way(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmptyResultClassification, fidl::Error> {
        let _response =
            self.client.send_query::<RunnerCallStrictOneWayRequest, EmptyResultClassification>(
                (target,),
                0x4edd0b6f52c0446b,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_flexible_one_way(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmptyResultClassification, fidl::Error> {
        let _response =
            self.client.send_query::<RunnerCallFlexibleOneWayRequest, EmptyResultClassification>(
                (target,),
                0x7253f10a77dfe817,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_strict_two_way(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmptyResultClassification, fidl::Error> {
        let _response =
            self.client.send_query::<RunnerCallStrictTwoWayRequest, EmptyResultClassification>(
                (target,),
                0x1fa9fb7414aedd27,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_strict_two_way_fields(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NonEmptyResultClassification, fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerCallStrictTwoWayFieldsRequest, NonEmptyResultClassification>(
                (target,),
                0x6f690e00ebf6f123,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_strict_two_way_err(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmptyResultWithErrorClassification, fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerCallStrictTwoWayErrRequest, EmptyResultWithErrorClassification>(
                (target,),
                0x51d6bc7cf6cbaf1a,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_strict_two_way_fields_err(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NonEmptyResultWithErrorClassification, fidl::Error> {
        let _response = self.client.send_query::<
            RunnerCallStrictTwoWayFieldsErrRequest,
            NonEmptyResultWithErrorClassification,
        >(
            (target,),
            0x6fa31ced05074c05,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    pub fn r#call_flexible_two_way(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmptyResultClassification, fidl::Error> {
        let _response =
            self.client.send_query::<RunnerCallFlexibleTwoWayRequest, EmptyResultClassification>(
                (target,),
                0x411f70724876d49,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_flexible_two_way_fields(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NonEmptyResultClassification, fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerCallFlexibleTwoWayFieldsRequest, NonEmptyResultClassification>(
                (target,),
                0x330996b623598eed,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_flexible_two_way_err(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<EmptyResultWithErrorClassification, fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerCallFlexibleTwoWayErrRequest, EmptyResultWithErrorClassification>(
                (target,),
                0x5ddbf88a353a2a57,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#call_flexible_two_way_fields_err(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NonEmptyResultWithErrorClassification, fidl::Error> {
        let _response = self.client.send_query::<
            RunnerCallFlexibleTwoWayFieldsErrRequest,
            NonEmptyResultWithErrorClassification,
        >(
            (target,),
            0x7ae309383b07048e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    pub fn r#receive_closed_events(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut reporter: fidl::endpoints::ClientEnd<ClosedTargetEventReporterMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerReceiveClosedEventsRequest, fidl::encoding::EmptyPayload>(
                (target, reporter),
                0x48da834910571aeb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#receive_ajar_events(
        &self,
        mut target: fidl::endpoints::ClientEnd<AjarTargetMarker>,
        mut reporter: fidl::endpoints::ClientEnd<AjarTargetEventReporterMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerReceiveAjarEventsRequest, fidl::encoding::EmptyPayload>(
                (target, reporter),
                0xc5662b9a9c007a3,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    pub fn r#receive_open_events(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        mut reporter: fidl::endpoints::ClientEnd<OpenTargetEventReporterMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<RunnerReceiveOpenEventsRequest, fidl::encoding::EmptyPayload>(
                (target, reporter),
                0x79a7073fd18edbdf,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

#[cfg(target_os = "fuchsia")]
impl From<RunnerSynchronousProxy> for zx::Handle {
    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)
    }
}

#[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.clientsuite/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#is_test_enabled(
        &self,
        mut test: Test,
    ) -> fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect> {
        RunnerProxyInterface::r#is_test_enabled(self, test)
    }

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

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

    pub fn r#call_two_way_no_payload(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_two_way_no_payload(self, target)
    }

    pub fn r#call_two_way_struct_payload(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        NonEmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_two_way_struct_payload(self, target)
    }

    pub fn r#call_two_way_table_payload(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        TableResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_two_way_table_payload(self, target)
    }

    pub fn r#call_two_way_union_payload(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        UnionResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_two_way_union_payload(self, target)
    }

    pub fn r#call_two_way_struct_payload_err(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        NonEmptyResultWithErrorClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_two_way_struct_payload_err(self, target)
    }

    pub fn r#call_two_way_struct_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &NonEmptyPayload,
    ) -> fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_two_way_struct_request(self, target, request)
    }

    pub fn r#call_two_way_table_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &TablePayload,
    ) -> fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_two_way_table_request(self, target, request)
    }

    pub fn r#call_two_way_union_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &UnionPayload,
    ) -> fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_two_way_union_request(self, target, request)
    }

    pub fn r#call_one_way_no_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_one_way_no_request(self, target)
    }

    pub fn r#call_one_way_struct_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &NonEmptyPayload,
    ) -> fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_one_way_struct_request(self, target, request)
    }

    pub fn r#call_one_way_table_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &TablePayload,
    ) -> fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_one_way_table_request(self, target, request)
    }

    pub fn r#call_one_way_union_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &UnionPayload,
    ) -> fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_one_way_union_request(self, target, request)
    }

    pub fn r#call_strict_one_way(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_strict_one_way(self, target)
    }

    pub fn r#call_flexible_one_way(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_flexible_one_way(self, target)
    }

    pub fn r#call_strict_two_way(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_strict_two_way(self, target)
    }

    pub fn r#call_strict_two_way_fields(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        NonEmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_strict_two_way_fields(self, target)
    }

    pub fn r#call_strict_two_way_err(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        EmptyResultWithErrorClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_strict_two_way_err(self, target)
    }

    pub fn r#call_strict_two_way_fields_err(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        NonEmptyResultWithErrorClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_strict_two_way_fields_err(self, target)
    }

    pub fn r#call_flexible_two_way(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_flexible_two_way(self, target)
    }

    pub fn r#call_flexible_two_way_fields(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        NonEmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_flexible_two_way_fields(self, target)
    }

    pub fn r#call_flexible_two_way_err(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        EmptyResultWithErrorClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_flexible_two_way_err(self, target)
    }

    pub fn r#call_flexible_two_way_fields_err(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> fidl::client::QueryResponseFut<
        NonEmptyResultWithErrorClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        RunnerProxyInterface::r#call_flexible_two_way_fields_err(self, target)
    }

    pub fn r#receive_closed_events(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut reporter: fidl::endpoints::ClientEnd<ClosedTargetEventReporterMarker>,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        RunnerProxyInterface::r#receive_closed_events(self, target, reporter)
    }

    pub fn r#receive_ajar_events(
        &self,
        mut target: fidl::endpoints::ClientEnd<AjarTargetMarker>,
        mut reporter: fidl::endpoints::ClientEnd<AjarTargetEventReporterMarker>,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        RunnerProxyInterface::r#receive_ajar_events(self, target, reporter)
    }

    pub fn r#receive_open_events(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        mut reporter: fidl::endpoints::ClientEnd<OpenTargetEventReporterMarker>,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        RunnerProxyInterface::r#receive_open_events(self, target, reporter)
    }
}

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,
                0x555d1430b913cdd4,
            >(_buf?)?;
            Ok(_response.version)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u64>(
            (),
            0x555d1430b913cdd4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type IsTestEnabledResponseFut =
        fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#is_test_enabled(&self, mut test: Test) -> Self::IsTestEnabledResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<bool, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                RunnerIsTestEnabledResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x755bc493368d7c50,
            >(_buf?)?;
            Ok(_response.is_enabled)
        }
        self.client.send_query_and_decode::<RunnerIsTestEnabledRequest, bool>(
            (test,),
            0x755bc493368d7c50,
            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,
                0x5a77b04abdfde130,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
            (),
            0x5a77b04abdfde130,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

    type CallTwoWayNoPayloadResponseFut = fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_two_way_no_payload(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> Self::CallTwoWayNoPayloadResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmptyResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EmptyResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x53ac710c20b320a1,
            >(_buf?)?;
            Ok(_response)
        }
        self.client
            .send_query_and_decode::<RunnerCallTwoWayNoPayloadRequest, EmptyResultClassification>(
                (target,),
                0x53ac710c20b320a1,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type CallTwoWayStructPayloadResponseFut = fidl::client::QueryResponseFut<
        NonEmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_two_way_struct_payload(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> Self::CallTwoWayStructPayloadResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NonEmptyResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NonEmptyResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x24e98c668499b946,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallTwoWayStructPayloadRequest,
            NonEmptyResultClassification,
        >(
            (target,),
            0x24e98c668499b946,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CallTwoWayTablePayloadResponseFut = fidl::client::QueryResponseFut<
        TableResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_two_way_table_payload(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> Self::CallTwoWayTablePayloadResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<TableResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                TableResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x72e428e1605b76a,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallTwoWayTablePayloadRequest,
            TableResultClassification,
        >(
            (target,),
            0x72e428e1605b76a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CallTwoWayUnionPayloadResponseFut = fidl::client::QueryResponseFut<
        UnionResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_two_way_union_payload(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> Self::CallTwoWayUnionPayloadResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<UnionResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                UnionResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7dc9d67218343860,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallTwoWayUnionPayloadRequest,
            UnionResultClassification,
        >(
            (target,),
            0x7dc9d67218343860,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CallTwoWayStructPayloadErrResponseFut = fidl::client::QueryResponseFut<
        NonEmptyResultWithErrorClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_two_way_struct_payload_err(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> Self::CallTwoWayStructPayloadErrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NonEmptyResultWithErrorClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NonEmptyResultWithErrorClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2b07a57942c5f6e5,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallTwoWayStructPayloadErrRequest,
            NonEmptyResultWithErrorClassification,
        >(
            (target,),
            0x2b07a57942c5f6e5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CallTwoWayStructRequestResponseFut = fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_two_way_struct_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &NonEmptyPayload,
    ) -> Self::CallTwoWayStructRequestResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmptyResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EmptyResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7c00a6ba2e6c9b45,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallTwoWayStructRequestRequest,
            EmptyResultClassification,
        >(
            (target, request,),
            0x7c00a6ba2e6c9b45,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CallTwoWayTableRequestResponseFut = fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_two_way_table_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &TablePayload,
    ) -> Self::CallTwoWayTableRequestResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmptyResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EmptyResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x641763237d3885be,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallTwoWayTableRequestRequest,
            EmptyResultClassification,
        >(
            (target, request,),
            0x641763237d3885be,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CallTwoWayUnionRequestResponseFut = fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_two_way_union_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &UnionPayload,
    ) -> Self::CallTwoWayUnionRequestResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmptyResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EmptyResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4be5f061df42619e,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallTwoWayUnionRequestRequest,
            EmptyResultClassification,
        >(
            (target, request,),
            0x4be5f061df42619e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CallOneWayNoRequestResponseFut = fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_one_way_no_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
    ) -> Self::CallOneWayNoRequestResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmptyResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EmptyResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x24b6eea8cbdccc09,
            >(_buf?)?;
            Ok(_response)
        }
        self.client
            .send_query_and_decode::<RunnerCallOneWayNoRequestRequest, EmptyResultClassification>(
                (target,),
                0x24b6eea8cbdccc09,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type CallOneWayStructRequestResponseFut = fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_one_way_struct_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &NonEmptyPayload,
    ) -> Self::CallOneWayStructRequestResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmptyResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EmptyResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x352a2907a0fcb420,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallOneWayStructRequestRequest,
            EmptyResultClassification,
        >(
            (target, request,),
            0x352a2907a0fcb420,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CallOneWayTableRequestResponseFut = fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_one_way_table_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &TablePayload,
    ) -> Self::CallOneWayTableRequestResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmptyResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EmptyResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x734121bf8bf336ef,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallOneWayTableRequestRequest,
            EmptyResultClassification,
        >(
            (target, request,),
            0x734121bf8bf336ef,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CallOneWayUnionRequestResponseFut = fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_one_way_union_request(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut request: &UnionPayload,
    ) -> Self::CallOneWayUnionRequestResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmptyResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EmptyResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x9be8e5eb7d50eb6,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallOneWayUnionRequestRequest,
            EmptyResultClassification,
        >(
            (target, request,),
            0x9be8e5eb7d50eb6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CallStrictOneWayResponseFut = fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_strict_one_way(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallStrictOneWayResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmptyResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EmptyResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4edd0b6f52c0446b,
            >(_buf?)?;
            Ok(_response)
        }
        self.client
            .send_query_and_decode::<RunnerCallStrictOneWayRequest, EmptyResultClassification>(
                (target,),
                0x4edd0b6f52c0446b,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type CallFlexibleOneWayResponseFut = fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_flexible_one_way(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallFlexibleOneWayResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmptyResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EmptyResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7253f10a77dfe817,
            >(_buf?)?;
            Ok(_response)
        }
        self.client
            .send_query_and_decode::<RunnerCallFlexibleOneWayRequest, EmptyResultClassification>(
                (target,),
                0x7253f10a77dfe817,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type CallStrictTwoWayResponseFut = fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_strict_two_way(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallStrictTwoWayResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmptyResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EmptyResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1fa9fb7414aedd27,
            >(_buf?)?;
            Ok(_response)
        }
        self.client
            .send_query_and_decode::<RunnerCallStrictTwoWayRequest, EmptyResultClassification>(
                (target,),
                0x1fa9fb7414aedd27,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type CallStrictTwoWayFieldsResponseFut = fidl::client::QueryResponseFut<
        NonEmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_strict_two_way_fields(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallStrictTwoWayFieldsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NonEmptyResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NonEmptyResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6f690e00ebf6f123,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallStrictTwoWayFieldsRequest,
            NonEmptyResultClassification,
        >(
            (target,),
            0x6f690e00ebf6f123,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CallStrictTwoWayErrResponseFut = fidl::client::QueryResponseFut<
        EmptyResultWithErrorClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_strict_two_way_err(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallStrictTwoWayErrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmptyResultWithErrorClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EmptyResultWithErrorClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x51d6bc7cf6cbaf1a,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallStrictTwoWayErrRequest,
            EmptyResultWithErrorClassification,
        >(
            (target,),
            0x51d6bc7cf6cbaf1a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CallStrictTwoWayFieldsErrResponseFut = fidl::client::QueryResponseFut<
        NonEmptyResultWithErrorClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_strict_two_way_fields_err(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallStrictTwoWayFieldsErrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NonEmptyResultWithErrorClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NonEmptyResultWithErrorClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6fa31ced05074c05,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallStrictTwoWayFieldsErrRequest,
            NonEmptyResultWithErrorClassification,
        >(
            (target,),
            0x6fa31ced05074c05,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CallFlexibleTwoWayResponseFut = fidl::client::QueryResponseFut<
        EmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_flexible_two_way(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallFlexibleTwoWayResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmptyResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EmptyResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x411f70724876d49,
            >(_buf?)?;
            Ok(_response)
        }
        self.client
            .send_query_and_decode::<RunnerCallFlexibleTwoWayRequest, EmptyResultClassification>(
                (target,),
                0x411f70724876d49,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type CallFlexibleTwoWayFieldsResponseFut = fidl::client::QueryResponseFut<
        NonEmptyResultClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_flexible_two_way_fields(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallFlexibleTwoWayFieldsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NonEmptyResultClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NonEmptyResultClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x330996b623598eed,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallFlexibleTwoWayFieldsRequest,
            NonEmptyResultClassification,
        >(
            (target,),
            0x330996b623598eed,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CallFlexibleTwoWayErrResponseFut = fidl::client::QueryResponseFut<
        EmptyResultWithErrorClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_flexible_two_way_err(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallFlexibleTwoWayErrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<EmptyResultWithErrorClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                EmptyResultWithErrorClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5ddbf88a353a2a57,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallFlexibleTwoWayErrRequest,
            EmptyResultWithErrorClassification,
        >(
            (target,),
            0x5ddbf88a353a2a57,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type CallFlexibleTwoWayFieldsErrResponseFut = fidl::client::QueryResponseFut<
        NonEmptyResultWithErrorClassification,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#call_flexible_two_way_fields_err(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
    ) -> Self::CallFlexibleTwoWayFieldsErrResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NonEmptyResultWithErrorClassification, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NonEmptyResultWithErrorClassification,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7ae309383b07048e,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            RunnerCallFlexibleTwoWayFieldsErrRequest,
            NonEmptyResultWithErrorClassification,
        >(
            (target,),
            0x7ae309383b07048e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReceiveClosedEventsResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#receive_closed_events(
        &self,
        mut target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        mut reporter: fidl::endpoints::ClientEnd<ClosedTargetEventReporterMarker>,
    ) -> Self::ReceiveClosedEventsResponseFut {
        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,
                0x48da834910571aeb,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<RunnerReceiveClosedEventsRequest, ()>(
            (target, reporter),
            0x48da834910571aeb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReceiveAjarEventsResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#receive_ajar_events(
        &self,
        mut target: fidl::endpoints::ClientEnd<AjarTargetMarker>,
        mut reporter: fidl::endpoints::ClientEnd<AjarTargetEventReporterMarker>,
    ) -> Self::ReceiveAjarEventsResponseFut {
        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,
                0xc5662b9a9c007a3,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<RunnerReceiveAjarEventsRequest, ()>(
            (target, reporter),
            0xc5662b9a9c007a3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReceiveOpenEventsResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#receive_open_events(
        &self,
        mut target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        mut reporter: fidl::endpoints::ClientEnd<OpenTargetEventReporterMarker>,
    ) -> Self::ReceiveOpenEventsResponseFut {
        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,
                0x79a7073fd18edbdf,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<RunnerReceiveOpenEventsRequest, ()>(
            (target, reporter),
            0x79a7073fd18edbdf,
            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 {}

impl RunnerEvent {
    /// 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 {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <RunnerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fidl.clientsuite/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 {
                    0x555d1430b913cdd4 => {
                        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,
                            },
                        })
                    }
                    0x755bc493368d7c50 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RunnerIsTestEnabledRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RunnerIsTestEnabledRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::IsTestEnabled {
                            test: req.test,

                            responder: RunnerIsTestEnabledResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5a77b04abdfde130 => {
                        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,
                            },
                        })
                    }
                    0x76b5610bfd4fa636 => {
                        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::GetBindingsProperties {
                            responder: RunnerGetBindingsPropertiesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x53ac710c20b320a1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RunnerCallTwoWayNoPayloadRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RunnerCallTwoWayNoPayloadRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::CallTwoWayNoPayload {
                            target: req.target,

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

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

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

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

                            responder: RunnerCallTwoWayStructPayloadErrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7c00a6ba2e6c9b45 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RunnerCallTwoWayStructRequestRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RunnerCallTwoWayStructRequestRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::CallTwoWayStructRequest {
                            target: req.target,
                            request: req.request,

                            responder: RunnerCallTwoWayStructRequestResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x641763237d3885be => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RunnerCallTwoWayTableRequestRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RunnerCallTwoWayTableRequestRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::CallTwoWayTableRequest {
                            target: req.target,
                            request: req.request,

                            responder: RunnerCallTwoWayTableRequestResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4be5f061df42619e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RunnerCallTwoWayUnionRequestRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RunnerCallTwoWayUnionRequestRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::CallTwoWayUnionRequest {
                            target: req.target,
                            request: req.request,

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

                            responder: RunnerCallOneWayNoRequestResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x352a2907a0fcb420 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RunnerCallOneWayStructRequestRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RunnerCallOneWayStructRequestRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::CallOneWayStructRequest {
                            target: req.target,
                            request: req.request,

                            responder: RunnerCallOneWayStructRequestResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x734121bf8bf336ef => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RunnerCallOneWayTableRequestRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RunnerCallOneWayTableRequestRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::CallOneWayTableRequest {
                            target: req.target,
                            request: req.request,

                            responder: RunnerCallOneWayTableRequestResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x9be8e5eb7d50eb6 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RunnerCallOneWayUnionRequestRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RunnerCallOneWayUnionRequestRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::CallOneWayUnionRequest {
                            target: req.target,
                            request: req.request,

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

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

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

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

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

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

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

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

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

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

                            responder: RunnerCallFlexibleTwoWayFieldsErrResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x48da834910571aeb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RunnerReceiveClosedEventsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RunnerReceiveClosedEventsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::ReceiveClosedEvents {
                            target: req.target,
                            reporter: req.reporter,

                            responder: RunnerReceiveClosedEventsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xc5662b9a9c007a3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RunnerReceiveAjarEventsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RunnerReceiveAjarEventsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::ReceiveAjarEvents {
                            target: req.target,
                            reporter: req.reporter,

                            responder: RunnerReceiveAjarEventsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x79a7073fd18edbdf => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            RunnerReceiveOpenEventsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RunnerReceiveOpenEventsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = RunnerControlHandle { inner: this.inner.clone() };
                        Ok(RunnerRequest::ReceiveOpenEvents {
                            target: req.target,
                            reporter: req.reporter,

                            responder: RunnerReceiveOpenEventsResponder {
                                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,
    },
    IsTestEnabled {
        test: Test,
        responder: RunnerIsTestEnabledResponder,
    },
    CheckAlive {
        responder: RunnerCheckAliveResponder,
    },
    GetBindingsProperties {
        responder: RunnerGetBindingsPropertiesResponder,
    },
    CallTwoWayNoPayload {
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        responder: RunnerCallTwoWayNoPayloadResponder,
    },
    CallTwoWayStructPayload {
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        responder: RunnerCallTwoWayStructPayloadResponder,
    },
    CallTwoWayTablePayload {
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        responder: RunnerCallTwoWayTablePayloadResponder,
    },
    CallTwoWayUnionPayload {
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        responder: RunnerCallTwoWayUnionPayloadResponder,
    },
    CallTwoWayStructPayloadErr {
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        responder: RunnerCallTwoWayStructPayloadErrResponder,
    },
    CallTwoWayStructRequest {
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        request: NonEmptyPayload,
        responder: RunnerCallTwoWayStructRequestResponder,
    },
    CallTwoWayTableRequest {
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        request: TablePayload,
        responder: RunnerCallTwoWayTableRequestResponder,
    },
    CallTwoWayUnionRequest {
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        request: UnionPayload,
        responder: RunnerCallTwoWayUnionRequestResponder,
    },
    CallOneWayNoRequest {
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        responder: RunnerCallOneWayNoRequestResponder,
    },
    CallOneWayStructRequest {
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        request: NonEmptyPayload,
        responder: RunnerCallOneWayStructRequestResponder,
    },
    CallOneWayTableRequest {
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        request: TablePayload,
        responder: RunnerCallOneWayTableRequestResponder,
    },
    CallOneWayUnionRequest {
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        request: UnionPayload,
        responder: RunnerCallOneWayUnionRequestResponder,
    },
    CallStrictOneWay {
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        responder: RunnerCallStrictOneWayResponder,
    },
    CallFlexibleOneWay {
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        responder: RunnerCallFlexibleOneWayResponder,
    },
    CallStrictTwoWay {
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        responder: RunnerCallStrictTwoWayResponder,
    },
    CallStrictTwoWayFields {
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        responder: RunnerCallStrictTwoWayFieldsResponder,
    },
    CallStrictTwoWayErr {
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        responder: RunnerCallStrictTwoWayErrResponder,
    },
    CallStrictTwoWayFieldsErr {
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        responder: RunnerCallStrictTwoWayFieldsErrResponder,
    },
    CallFlexibleTwoWay {
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        responder: RunnerCallFlexibleTwoWayResponder,
    },
    CallFlexibleTwoWayFields {
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        responder: RunnerCallFlexibleTwoWayFieldsResponder,
    },
    CallFlexibleTwoWayErr {
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        responder: RunnerCallFlexibleTwoWayErrResponder,
    },
    CallFlexibleTwoWayFieldsErr {
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        responder: RunnerCallFlexibleTwoWayFieldsErrResponder,
    },
    ReceiveClosedEvents {
        target: fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        reporter: fidl::endpoints::ClientEnd<ClosedTargetEventReporterMarker>,
        responder: RunnerReceiveClosedEventsResponder,
    },
    ReceiveAjarEvents {
        target: fidl::endpoints::ClientEnd<AjarTargetMarker>,
        reporter: fidl::endpoints::ClientEnd<AjarTargetEventReporterMarker>,
        responder: RunnerReceiveAjarEventsResponder,
    },
    ReceiveOpenEvents {
        target: fidl::endpoints::ClientEnd<OpenTargetMarker>,
        reporter: fidl::endpoints::ClientEnd<OpenTargetEventReporterMarker>,
        responder: RunnerReceiveOpenEventsResponder,
    },
}

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_is_test_enabled(self) -> Option<(Test, RunnerIsTestEnabledResponder)> {
        if let RunnerRequest::IsTestEnabled { test, responder } = self {
            Some((test, 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_get_bindings_properties(self) -> Option<(RunnerGetBindingsPropertiesResponder)> {
        if let RunnerRequest::GetBindingsProperties { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_two_way_no_payload(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<ClosedTargetMarker>, RunnerCallTwoWayNoPayloadResponder)>
    {
        if let RunnerRequest::CallTwoWayNoPayload { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_two_way_struct_payload(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        RunnerCallTwoWayStructPayloadResponder,
    )> {
        if let RunnerRequest::CallTwoWayStructPayload { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_two_way_table_payload(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        RunnerCallTwoWayTablePayloadResponder,
    )> {
        if let RunnerRequest::CallTwoWayTablePayload { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_two_way_union_payload(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        RunnerCallTwoWayUnionPayloadResponder,
    )> {
        if let RunnerRequest::CallTwoWayUnionPayload { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_two_way_struct_payload_err(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        RunnerCallTwoWayStructPayloadErrResponder,
    )> {
        if let RunnerRequest::CallTwoWayStructPayloadErr { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_two_way_struct_request(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        NonEmptyPayload,
        RunnerCallTwoWayStructRequestResponder,
    )> {
        if let RunnerRequest::CallTwoWayStructRequest { target, request, responder } = self {
            Some((target, request, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_two_way_table_request(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        TablePayload,
        RunnerCallTwoWayTableRequestResponder,
    )> {
        if let RunnerRequest::CallTwoWayTableRequest { target, request, responder } = self {
            Some((target, request, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_two_way_union_request(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        UnionPayload,
        RunnerCallTwoWayUnionRequestResponder,
    )> {
        if let RunnerRequest::CallTwoWayUnionRequest { target, request, responder } = self {
            Some((target, request, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_one_way_no_request(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<ClosedTargetMarker>, RunnerCallOneWayNoRequestResponder)>
    {
        if let RunnerRequest::CallOneWayNoRequest { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_one_way_struct_request(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        NonEmptyPayload,
        RunnerCallOneWayStructRequestResponder,
    )> {
        if let RunnerRequest::CallOneWayStructRequest { target, request, responder } = self {
            Some((target, request, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_one_way_table_request(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        TablePayload,
        RunnerCallOneWayTableRequestResponder,
    )> {
        if let RunnerRequest::CallOneWayTableRequest { target, request, responder } = self {
            Some((target, request, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_one_way_union_request(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        UnionPayload,
        RunnerCallOneWayUnionRequestResponder,
    )> {
        if let RunnerRequest::CallOneWayUnionRequest { target, request, responder } = self {
            Some((target, request, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_strict_one_way(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<OpenTargetMarker>, RunnerCallStrictOneWayResponder)>
    {
        if let RunnerRequest::CallStrictOneWay { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_flexible_one_way(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<OpenTargetMarker>, RunnerCallFlexibleOneWayResponder)>
    {
        if let RunnerRequest::CallFlexibleOneWay { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_strict_two_way(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<OpenTargetMarker>, RunnerCallStrictTwoWayResponder)>
    {
        if let RunnerRequest::CallStrictTwoWay { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_strict_two_way_fields(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<OpenTargetMarker>, RunnerCallStrictTwoWayFieldsResponder)>
    {
        if let RunnerRequest::CallStrictTwoWayFields { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_strict_two_way_err(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<OpenTargetMarker>, RunnerCallStrictTwoWayErrResponder)>
    {
        if let RunnerRequest::CallStrictTwoWayErr { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_strict_two_way_fields_err(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<OpenTargetMarker>,
        RunnerCallStrictTwoWayFieldsErrResponder,
    )> {
        if let RunnerRequest::CallStrictTwoWayFieldsErr { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_flexible_two_way(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<OpenTargetMarker>, RunnerCallFlexibleTwoWayResponder)>
    {
        if let RunnerRequest::CallFlexibleTwoWay { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_flexible_two_way_fields(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<OpenTargetMarker>,
        RunnerCallFlexibleTwoWayFieldsResponder,
    )> {
        if let RunnerRequest::CallFlexibleTwoWayFields { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_flexible_two_way_err(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<OpenTargetMarker>, RunnerCallFlexibleTwoWayErrResponder)>
    {
        if let RunnerRequest::CallFlexibleTwoWayErr { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_call_flexible_two_way_fields_err(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<OpenTargetMarker>,
        RunnerCallFlexibleTwoWayFieldsErrResponder,
    )> {
        if let RunnerRequest::CallFlexibleTwoWayFieldsErr { target, responder } = self {
            Some((target, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_receive_closed_events(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<ClosedTargetMarker>,
        fidl::endpoints::ClientEnd<ClosedTargetEventReporterMarker>,
        RunnerReceiveClosedEventsResponder,
    )> {
        if let RunnerRequest::ReceiveClosedEvents { target, reporter, responder } = self {
            Some((target, reporter, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_receive_ajar_events(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<AjarTargetMarker>,
        fidl::endpoints::ClientEnd<AjarTargetEventReporterMarker>,
        RunnerReceiveAjarEventsResponder,
    )> {
        if let RunnerRequest::ReceiveAjarEvents { target, reporter, responder } = self {
            Some((target, reporter, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_receive_open_events(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<OpenTargetMarker>,
        fidl::endpoints::ClientEnd<OpenTargetEventReporterMarker>,
        RunnerReceiveOpenEventsResponder,
    )> {
        if let RunnerRequest::ReceiveOpenEvents { target, reporter, responder } = self {
            Some((target, reporter, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            RunnerRequest::GetVersion { .. } => "get_version",
            RunnerRequest::IsTestEnabled { .. } => "is_test_enabled",
            RunnerRequest::CheckAlive { .. } => "check_alive",
            RunnerRequest::GetBindingsProperties { .. } => "get_bindings_properties",
            RunnerRequest::CallTwoWayNoPayload { .. } => "call_two_way_no_payload",
            RunnerRequest::CallTwoWayStructPayload { .. } => "call_two_way_struct_payload",
            RunnerRequest::CallTwoWayTablePayload { .. } => "call_two_way_table_payload",
            RunnerRequest::CallTwoWayUnionPayload { .. } => "call_two_way_union_payload",
            RunnerRequest::CallTwoWayStructPayloadErr { .. } => "call_two_way_struct_payload_err",
            RunnerRequest::CallTwoWayStructRequest { .. } => "call_two_way_struct_request",
            RunnerRequest::CallTwoWayTableRequest { .. } => "call_two_way_table_request",
            RunnerRequest::CallTwoWayUnionRequest { .. } => "call_two_way_union_request",
            RunnerRequest::CallOneWayNoRequest { .. } => "call_one_way_no_request",
            RunnerRequest::CallOneWayStructRequest { .. } => "call_one_way_struct_request",
            RunnerRequest::CallOneWayTableRequest { .. } => "call_one_way_table_request",
            RunnerRequest::CallOneWayUnionRequest { .. } => "call_one_way_union_request",
            RunnerRequest::CallStrictOneWay { .. } => "call_strict_one_way",
            RunnerRequest::CallFlexibleOneWay { .. } => "call_flexible_one_way",
            RunnerRequest::CallStrictTwoWay { .. } => "call_strict_two_way",
            RunnerRequest::CallStrictTwoWayFields { .. } => "call_strict_two_way_fields",
            RunnerRequest::CallStrictTwoWayErr { .. } => "call_strict_two_way_err",
            RunnerRequest::CallStrictTwoWayFieldsErr { .. } => "call_strict_two_way_fields_err",
            RunnerRequest::CallFlexibleTwoWay { .. } => "call_flexible_two_way",
            RunnerRequest::CallFlexibleTwoWayFields { .. } => "call_flexible_two_way_fields",
            RunnerRequest::CallFlexibleTwoWayErr { .. } => "call_flexible_two_way_err",
            RunnerRequest::CallFlexibleTwoWayFieldsErr { .. } => "call_flexible_two_way_fields_err",
            RunnerRequest::ReceiveClosedEvents { .. } => "receive_closed_events",
            RunnerRequest::ReceiveAjarEvents { .. } => "receive_ajar_events",
            RunnerRequest::ReceiveOpenEvents { .. } => "receive_open_events",
        }
    }
}

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

impl fidl::endpoints::ControlHandle for RunnerControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

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

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

impl RunnerControlHandle {}

#[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,
            0x555d1430b913cdd4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

    fn send_raw(&self, mut is_enabled: bool) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<RunnerIsTestEnabledResponse>(
            (is_enabled,),
            self.tx_id,
            0x755bc493368d7c50,
            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,
            0x5a77b04abdfde130,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct RunnerReceiveClosedEventsResponder {
    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 RunnerReceiveClosedEventsResponder {
    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 RunnerReceiveClosedEventsResponder {
    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 RunnerReceiveClosedEventsResponder {
    /// 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,
            0x48da834910571aeb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct RunnerReceiveAjarEventsResponder {
    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 RunnerReceiveAjarEventsResponder {
    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 RunnerReceiveAjarEventsResponder {
    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 RunnerReceiveAjarEventsResponder {
    /// 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,
            0xc5662b9a9c007a3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct RunnerReceiveOpenEventsResponder {
    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 RunnerReceiveOpenEventsResponder {
    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 RunnerReceiveOpenEventsResponder {
    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 RunnerReceiveOpenEventsResponder {
    /// 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,
            0x79a7073fd18edbdf,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for RunnerCallFlexibleOneWayRequest {
        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 RunnerCallFlexibleOneWayRequest {
        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<
            RunnerCallFlexibleOneWayRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallFlexibleOneWayRequest
    {
        #[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::<RunnerCallFlexibleOneWayRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallFlexibleOneWayRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallFlexibleOneWayRequest,
            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::<RunnerCallFlexibleOneWayRequest>(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 RunnerCallFlexibleOneWayRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RunnerCallFlexibleTwoWayErrRequest {
        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 RunnerCallFlexibleTwoWayErrRequest {
        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<
            RunnerCallFlexibleTwoWayErrRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallFlexibleTwoWayErrRequest
    {
        #[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::<RunnerCallFlexibleTwoWayErrRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallFlexibleTwoWayErrRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallFlexibleTwoWayErrRequest,
            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::<RunnerCallFlexibleTwoWayErrRequest>(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 RunnerCallFlexibleTwoWayErrRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RunnerCallFlexibleTwoWayFieldsErrRequest {
        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 RunnerCallFlexibleTwoWayFieldsErrRequest {
        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<
            RunnerCallFlexibleTwoWayFieldsErrRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallFlexibleTwoWayFieldsErrRequest
    {
        #[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::<RunnerCallFlexibleTwoWayFieldsErrRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallFlexibleTwoWayFieldsErrRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallFlexibleTwoWayFieldsErrRequest,
            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::<RunnerCallFlexibleTwoWayFieldsErrRequest>(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 RunnerCallFlexibleTwoWayFieldsErrRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RunnerCallFlexibleTwoWayFieldsRequest {
        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 RunnerCallFlexibleTwoWayFieldsRequest {
        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<
            RunnerCallFlexibleTwoWayFieldsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallFlexibleTwoWayFieldsRequest
    {
        #[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::<RunnerCallFlexibleTwoWayFieldsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallFlexibleTwoWayFieldsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallFlexibleTwoWayFieldsRequest,
            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::<RunnerCallFlexibleTwoWayFieldsRequest>(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 RunnerCallFlexibleTwoWayFieldsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RunnerCallFlexibleTwoWayRequest {
        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 RunnerCallFlexibleTwoWayRequest {
        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<
            RunnerCallFlexibleTwoWayRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallFlexibleTwoWayRequest
    {
        #[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::<RunnerCallFlexibleTwoWayRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallFlexibleTwoWayRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallFlexibleTwoWayRequest,
            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::<RunnerCallFlexibleTwoWayRequest>(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 RunnerCallFlexibleTwoWayRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RunnerCallOneWayNoRequestRequest {
        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 RunnerCallOneWayNoRequestRequest {
        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<
            RunnerCallOneWayNoRequestRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallOneWayNoRequestRequest
    {
        #[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::<RunnerCallOneWayNoRequestRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallOneWayNoRequestRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallOneWayNoRequestRequest,
            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::<RunnerCallOneWayNoRequestRequest>(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 RunnerCallOneWayNoRequestRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RunnerCallOneWayStructRequestRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallOneWayStructRequestRequest
    {
        #[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::<RunnerCallOneWayStructRequestRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallOneWayStructRequestRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                    <NonEmptyPayload as fidl::encoding::ValueTypeMarker>::borrow(&self.request),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<NonEmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect>,
        >
        fidl::encoding::Encode<
            RunnerCallOneWayStructRequestRequest,
            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::<RunnerCallOneWayStructRequestRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RunnerCallOneWayStructRequestRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                request: fidl::new_empty!(
                    NonEmptyPayload,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

    impl fidl::encoding::ResourceTypeMarker for RunnerCallStrictOneWayRequest {
        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 RunnerCallStrictOneWayRequest {
        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<
            RunnerCallStrictOneWayRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallStrictOneWayRequest
    {
        #[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::<RunnerCallStrictOneWayRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallStrictOneWayRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallStrictOneWayRequest,
            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::<RunnerCallStrictOneWayRequest>(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 RunnerCallStrictOneWayRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RunnerCallStrictTwoWayErrRequest {
        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 RunnerCallStrictTwoWayErrRequest {
        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<
            RunnerCallStrictTwoWayErrRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallStrictTwoWayErrRequest
    {
        #[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::<RunnerCallStrictTwoWayErrRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallStrictTwoWayErrRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallStrictTwoWayErrRequest,
            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::<RunnerCallStrictTwoWayErrRequest>(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 RunnerCallStrictTwoWayErrRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RunnerCallStrictTwoWayFieldsErrRequest {
        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 RunnerCallStrictTwoWayFieldsErrRequest {
        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<
            RunnerCallStrictTwoWayFieldsErrRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallStrictTwoWayFieldsErrRequest
    {
        #[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::<RunnerCallStrictTwoWayFieldsErrRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallStrictTwoWayFieldsErrRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallStrictTwoWayFieldsErrRequest,
            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::<RunnerCallStrictTwoWayFieldsErrRequest>(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 RunnerCallStrictTwoWayFieldsErrRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RunnerCallStrictTwoWayFieldsRequest {
        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 RunnerCallStrictTwoWayFieldsRequest {
        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<
            RunnerCallStrictTwoWayFieldsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallStrictTwoWayFieldsRequest
    {
        #[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::<RunnerCallStrictTwoWayFieldsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallStrictTwoWayFieldsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallStrictTwoWayFieldsRequest,
            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::<RunnerCallStrictTwoWayFieldsRequest>(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 RunnerCallStrictTwoWayFieldsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RunnerCallStrictTwoWayRequest {
        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 RunnerCallStrictTwoWayRequest {
        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<
            RunnerCallStrictTwoWayRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallStrictTwoWayRequest
    {
        #[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::<RunnerCallStrictTwoWayRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallStrictTwoWayRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallStrictTwoWayRequest,
            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::<RunnerCallStrictTwoWayRequest>(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 RunnerCallStrictTwoWayRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RunnerCallTwoWayNoPayloadRequest {
        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 RunnerCallTwoWayNoPayloadRequest {
        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<
            RunnerCallTwoWayNoPayloadRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallTwoWayNoPayloadRequest
    {
        #[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::<RunnerCallTwoWayNoPayloadRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallTwoWayNoPayloadRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallTwoWayNoPayloadRequest,
            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::<RunnerCallTwoWayNoPayloadRequest>(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 RunnerCallTwoWayNoPayloadRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RunnerCallTwoWayStructPayloadErrRequest {
        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 RunnerCallTwoWayStructPayloadErrRequest {
        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<
            RunnerCallTwoWayStructPayloadErrRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallTwoWayStructPayloadErrRequest
    {
        #[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::<RunnerCallTwoWayStructPayloadErrRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallTwoWayStructPayloadErrRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallTwoWayStructPayloadErrRequest,
            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::<RunnerCallTwoWayStructPayloadErrRequest>(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 RunnerCallTwoWayStructPayloadErrRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RunnerCallTwoWayStructPayloadRequest {
        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 RunnerCallTwoWayStructPayloadRequest {
        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<
            RunnerCallTwoWayStructPayloadRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallTwoWayStructPayloadRequest
    {
        #[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::<RunnerCallTwoWayStructPayloadRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallTwoWayStructPayloadRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallTwoWayStructPayloadRequest,
            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::<RunnerCallTwoWayStructPayloadRequest>(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 RunnerCallTwoWayStructPayloadRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RunnerCallTwoWayStructRequestRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallTwoWayStructRequestRequest
    {
        #[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::<RunnerCallTwoWayStructRequestRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallTwoWayStructRequestRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                    <NonEmptyPayload as fidl::encoding::ValueTypeMarker>::borrow(&self.request),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<NonEmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect>,
        >
        fidl::encoding::Encode<
            RunnerCallTwoWayStructRequestRequest,
            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::<RunnerCallTwoWayStructRequestRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RunnerCallTwoWayStructRequestRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                request: fidl::new_empty!(
                    NonEmptyPayload,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for RunnerCallTwoWayTablePayloadRequest {
        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 RunnerCallTwoWayTablePayloadRequest {
        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<
            RunnerCallTwoWayTablePayloadRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallTwoWayTablePayloadRequest
    {
        #[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::<RunnerCallTwoWayTablePayloadRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallTwoWayTablePayloadRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallTwoWayTablePayloadRequest,
            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::<RunnerCallTwoWayTablePayloadRequest>(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 RunnerCallTwoWayTablePayloadRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

    impl fidl::encoding::ResourceTypeMarker for RunnerCallTwoWayUnionPayloadRequest {
        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 RunnerCallTwoWayUnionPayloadRequest {
        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<
            RunnerCallTwoWayUnionPayloadRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerCallTwoWayUnionPayloadRequest
    {
        #[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::<RunnerCallTwoWayUnionPayloadRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerCallTwoWayUnionPayloadRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerCallTwoWayUnionPayloadRequest,
            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::<RunnerCallTwoWayUnionPayloadRequest>(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 RunnerCallTwoWayUnionPayloadRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RunnerReceiveAjarEventsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerReceiveAjarEventsRequest
    {
        #[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::<RunnerReceiveAjarEventsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerReceiveAjarEventsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<AjarTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<AjarTargetEventReporterMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.reporter),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<AjarTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<AjarTargetEventReporterMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerReceiveAjarEventsRequest,
            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::<RunnerReceiveAjarEventsRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RunnerReceiveAjarEventsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<AjarTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                reporter: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<AjarTargetEventReporterMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RunnerReceiveClosedEventsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerReceiveClosedEventsRequest
    {
        #[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::<RunnerReceiveClosedEventsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerReceiveClosedEventsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetEventReporterMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.reporter),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<ClosedTargetEventReporterMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerReceiveClosedEventsRequest,
            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::<RunnerReceiveClosedEventsRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RunnerReceiveClosedEventsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ClosedTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                reporter: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<ClosedTargetEventReporterMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            RunnerReceiveOpenEventsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RunnerReceiveOpenEventsRequest
    {
        #[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::<RunnerReceiveOpenEventsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerReceiveOpenEventsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.target),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetEventReporterMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.reporter),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetEventReporterMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            RunnerReceiveOpenEventsRequest,
            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::<RunnerReceiveOpenEventsRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for RunnerReceiveOpenEventsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<OpenTargetMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                reporter: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<OpenTargetEventReporterMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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