fidl_fuchsia_ui_test_conformance/

fidl_fuchsia_ui_test_conformance.rs

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

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

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

/// Used to create a puppet instance.
#[derive(Debug, Default, PartialEq)]
pub struct PuppetCreationArgs {
    pub server_end: Option<fidl::endpoints::ServerEnd<PuppetMarker>>,
    pub view_token: Option<fidl_fuchsia_ui_views::ViewCreationToken>,
    pub touch_listener:
        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_test_input::TouchInputListenerMarker>>,
    pub mouse_listener:
        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_test_input::MouseInputListenerMarker>>,
    pub keyboard_listener:
        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_test_input::KeyboardInputListenerMarker>>,
    pub flatland_client:
        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_composition::FlatlandMarker>>,
    pub keyboard_client: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardMarker>>,
    pub device_pixel_ratio: Option<f32>,
    pub focuser: Option<fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::FocuserMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct PuppetEmbedRemoteViewResponse {
    pub result: Option<Result_>,
    pub view_creation_token: Option<fidl_fuchsia_ui_views::ViewCreationToken>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct PuppetFactoryCreateResponse {
    pub result: Option<Result_>,
    /// view_ref of the created view.
    pub view_ref: Option<fidl_fuchsia_ui_views::ViewRef>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

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

impl fidl::endpoints::ProtocolMarker for PuppetMarker {
    type Proxy = PuppetProxy;
    type RequestStream = PuppetRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PuppetSynchronousProxy;

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

pub trait PuppetProxyInterface: Send + Sync {
    type EmbedRemoteViewResponseFut: std::future::Future<Output = Result<PuppetEmbedRemoteViewResponse, fidl::Error>>
        + Send;
    fn r#embed_remote_view(
        &self,
        payload: &PuppetEmbedRemoteViewRequest,
    ) -> Self::EmbedRemoteViewResponseFut;
    type SetEmbeddedViewPropertiesResponseFut: std::future::Future<Output = Result<PuppetSetEmbeddedViewPropertiesResponse, fidl::Error>>
        + Send;
    fn r#set_embedded_view_properties(
        &self,
        payload: &PuppetSetEmbeddedViewPropertiesRequest,
    ) -> Self::SetEmbeddedViewPropertiesResponseFut;
    type DrawImageResponseFut: std::future::Future<Output = Result<PuppetDrawImageResponse, fidl::Error>>
        + Send;
    fn r#draw_image(&self, payload: &PuppetDrawImageRequest) -> Self::DrawImageResponseFut;
    type SetImagePropertiesResponseFut: std::future::Future<Output = Result<PuppetSetImagePropertiesResponse, fidl::Error>>
        + Send;
    fn r#set_image_properties(
        &self,
        payload: &PuppetSetImagePropertiesRequest,
    ) -> Self::SetImagePropertiesResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PuppetSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PuppetSynchronousProxy {
    type Proxy = PuppetProxy;
    type Protocol = PuppetMarker;

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

    /// Embeds a view owned elsewhere.
    ///
    /// The puppet should create a (ViewportCreationToken, ViewCreationToken) pair
    /// and use the former to create a viewport with the specified `properties`.
    /// Once the puppet has presented a frame containing the new viewport, it should
    /// return the view creation token to the caller.
    pub fn r#embed_remote_view(
        &self,
        mut payload: &PuppetEmbedRemoteViewRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PuppetEmbedRemoteViewResponse, fidl::Error> {
        let _response =
            self.client.send_query::<PuppetEmbedRemoteViewRequest, PuppetEmbedRemoteViewResponse>(
                payload,
                0x5bb2325a988aa137,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Updates the properties of an embedded view.
    pub fn r#set_embedded_view_properties(
        &self,
        mut payload: &PuppetSetEmbeddedViewPropertiesRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PuppetSetEmbeddedViewPropertiesResponse, fidl::Error> {
        let _response = self.client.send_query::<
            PuppetSetEmbeddedViewPropertiesRequest,
            PuppetSetEmbeddedViewPropertiesResponse,
        >(
            payload,
            0x409a7f3de135c709,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Draws an image composed of solid, monochrome-filled rectangles.
    pub fn r#draw_image(
        &self,
        mut payload: &PuppetDrawImageRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PuppetDrawImageResponse, fidl::Error> {
        let _response = self.client.send_query::<PuppetDrawImageRequest, PuppetDrawImageResponse>(
            payload,
            0x6d736daa48b835cc,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }

    /// Updates the properties of an image.
    pub fn r#set_image_properties(
        &self,
        mut payload: &PuppetSetImagePropertiesRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PuppetSetImagePropertiesResponse, fidl::Error> {
        let _response = self
            .client
            .send_query::<PuppetSetImagePropertiesRequest, PuppetSetImagePropertiesResponse>(
                payload,
                0x2683795408d033ff,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

impl fidl::endpoints::Proxy for PuppetProxy {
    type Protocol = PuppetMarker;

    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 PuppetProxy {
    /// Create a new Proxy for fuchsia.ui.test.conformance/Puppet.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PuppetMarker 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) -> PuppetEventStream {
        PuppetEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Embeds a view owned elsewhere.
    ///
    /// The puppet should create a (ViewportCreationToken, ViewCreationToken) pair
    /// and use the former to create a viewport with the specified `properties`.
    /// Once the puppet has presented a frame containing the new viewport, it should
    /// return the view creation token to the caller.
    pub fn r#embed_remote_view(
        &self,
        mut payload: &PuppetEmbedRemoteViewRequest,
    ) -> fidl::client::QueryResponseFut<
        PuppetEmbedRemoteViewResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PuppetProxyInterface::r#embed_remote_view(self, payload)
    }

    /// Updates the properties of an embedded view.
    pub fn r#set_embedded_view_properties(
        &self,
        mut payload: &PuppetSetEmbeddedViewPropertiesRequest,
    ) -> fidl::client::QueryResponseFut<
        PuppetSetEmbeddedViewPropertiesResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PuppetProxyInterface::r#set_embedded_view_properties(self, payload)
    }

    /// Draws an image composed of solid, monochrome-filled rectangles.
    pub fn r#draw_image(
        &self,
        mut payload: &PuppetDrawImageRequest,
    ) -> fidl::client::QueryResponseFut<
        PuppetDrawImageResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PuppetProxyInterface::r#draw_image(self, payload)
    }

    /// Updates the properties of an image.
    pub fn r#set_image_properties(
        &self,
        mut payload: &PuppetSetImagePropertiesRequest,
    ) -> fidl::client::QueryResponseFut<
        PuppetSetImagePropertiesResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PuppetProxyInterface::r#set_image_properties(self, payload)
    }
}

impl PuppetProxyInterface for PuppetProxy {
    type EmbedRemoteViewResponseFut = fidl::client::QueryResponseFut<
        PuppetEmbedRemoteViewResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#embed_remote_view(
        &self,
        mut payload: &PuppetEmbedRemoteViewRequest,
    ) -> Self::EmbedRemoteViewResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PuppetEmbedRemoteViewResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PuppetEmbedRemoteViewResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5bb2325a988aa137,
            >(_buf?)?;
            Ok(_response)
        }
        self.client
            .send_query_and_decode::<PuppetEmbedRemoteViewRequest, PuppetEmbedRemoteViewResponse>(
                payload,
                0x5bb2325a988aa137,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

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

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

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

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.ui.test.conformance/Puppet.
pub struct PuppetRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for PuppetRequestStream {
    type Protocol = PuppetMarker;
    type ControlHandle = PuppetControlHandle;

    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 {
        PuppetControlHandle { 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 PuppetRequestStream {
    type Item = Result<PuppetRequest, 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 PuppetRequestStream 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 {
                    0x5bb2325a988aa137 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PuppetEmbedRemoteViewRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PuppetEmbedRemoteViewRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PuppetControlHandle { inner: this.inner.clone() };
                        Ok(PuppetRequest::EmbedRemoteView {
                            payload: req,
                            responder: PuppetEmbedRemoteViewResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x409a7f3de135c709 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PuppetSetEmbeddedViewPropertiesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PuppetSetEmbeddedViewPropertiesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PuppetControlHandle { inner: this.inner.clone() };
                        Ok(PuppetRequest::SetEmbeddedViewProperties {
                            payload: req,
                            responder: PuppetSetEmbeddedViewPropertiesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6d736daa48b835cc => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PuppetDrawImageRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PuppetDrawImageRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PuppetControlHandle { inner: this.inner.clone() };
                        Ok(PuppetRequest::DrawImage {
                            payload: req,
                            responder: PuppetDrawImageResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2683795408d033ff => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PuppetSetImagePropertiesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PuppetSetImagePropertiesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = PuppetControlHandle { inner: this.inner.clone() };
                        Ok(PuppetRequest::SetImageProperties {
                            payload: req,
                            responder: PuppetSetImagePropertiesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <PuppetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// ******************************* PLEASE READ *******************************
///
/// A tool to help developers write generalizable tests against a well-defined
/// client application ("the puppet"). This API is not intended to cover every
/// possible UI platform API use case.
///
/// TOPOLOGY
///
/// Each puppet is assumed to own exactly one view.
///
/// Each piece of content added is assumed to be a "direct child" of this view;
/// and a sibling of the rest of the view's contents. In other words, all
/// embedded views, filled rects, etc. are considered to have "sibling" semantics;
/// for example, repositioning or resizing one piece of content should not
/// reposition/resize any other piece of content.
///
/// Z-ORDERING
///
/// The contents of a puppet's view are z-ordered according to the order in which
/// they were created. The first piece of content created appears at the "bottom",
/// and the last piece of content created appears at the "top".
///
/// IDS
///
/// All ids must be globally unique, e.g. a "filled rect" id belongs to the same
/// id space as an "embedded view" id.
///
/// SYNCHRONIZATION
///
/// All methods should block until the frame containing the requested changes has
/// rendered to the display, if a new frame is required.
///
/// RETURN VALUES
///
/// See documentation on the `Result` enum above.
///
/// UNKNOWN INTERACTIONS
///
/// Puppet implementations may live outside of fuchsia.git, so they will encounter
/// unknown methods and/or fields any time we extend the puppet API. In these cases,
/// the puppet should always return `UNSUPPORTED`.
#[derive(Debug)]
pub enum PuppetRequest {
    /// Embeds a view owned elsewhere.
    ///
    /// The puppet should create a (ViewportCreationToken, ViewCreationToken) pair
    /// and use the former to create a viewport with the specified `properties`.
    /// Once the puppet has presented a frame containing the new viewport, it should
    /// return the view creation token to the caller.
    EmbedRemoteView {
        payload: PuppetEmbedRemoteViewRequest,
        responder: PuppetEmbedRemoteViewResponder,
    },
    /// Updates the properties of an embedded view.
    SetEmbeddedViewProperties {
        payload: PuppetSetEmbeddedViewPropertiesRequest,
        responder: PuppetSetEmbeddedViewPropertiesResponder,
    },
    /// Draws an image composed of solid, monochrome-filled rectangles.
    DrawImage { payload: PuppetDrawImageRequest, responder: PuppetDrawImageResponder },
    /// Updates the properties of an image.
    SetImageProperties {
        payload: PuppetSetImagePropertiesRequest,
        responder: PuppetSetImagePropertiesResponder,
    },
}

impl PuppetRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_embed_remote_view(
        self,
    ) -> Option<(PuppetEmbedRemoteViewRequest, PuppetEmbedRemoteViewResponder)> {
        if let PuppetRequest::EmbedRemoteView { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_embedded_view_properties(
        self,
    ) -> Option<(PuppetSetEmbeddedViewPropertiesRequest, PuppetSetEmbeddedViewPropertiesResponder)>
    {
        if let PuppetRequest::SetEmbeddedViewProperties { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_draw_image(self) -> Option<(PuppetDrawImageRequest, PuppetDrawImageResponder)> {
        if let PuppetRequest::DrawImage { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_image_properties(
        self,
    ) -> Option<(PuppetSetImagePropertiesRequest, PuppetSetImagePropertiesResponder)> {
        if let PuppetRequest::SetImageProperties { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PuppetRequest::EmbedRemoteView { .. } => "embed_remote_view",
            PuppetRequest::SetEmbeddedViewProperties { .. } => "set_embedded_view_properties",
            PuppetRequest::DrawImage { .. } => "draw_image",
            PuppetRequest::SetImageProperties { .. } => "set_image_properties",
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for PuppetFactoryMarker {
    type Proxy = PuppetFactoryProxy;
    type RequestStream = PuppetFactoryRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PuppetFactorySynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.ui.test.conformance.PuppetFactory";
}
impl fidl::endpoints::DiscoverableProtocolMarker for PuppetFactoryMarker {}

pub trait PuppetFactoryProxyInterface: Send + Sync {
    type CreateResponseFut: std::future::Future<Output = Result<PuppetFactoryCreateResponse, fidl::Error>>
        + Send;
    fn r#create(&self, payload: PuppetCreationArgs) -> Self::CreateResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PuppetFactorySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PuppetFactorySynchronousProxy {
    type Proxy = PuppetFactoryProxy;
    type Protocol = PuppetFactoryMarker;

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

    /// Spawns a puppet instance, which will own a view created using `view_token`, and
    /// binds `puppet_server` to it.
    pub fn r#create(
        &self,
        mut payload: PuppetCreationArgs,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<PuppetFactoryCreateResponse, fidl::Error> {
        let _response = self.client.send_query::<PuppetCreationArgs, PuppetFactoryCreateResponse>(
            &mut payload,
            0x4f90811dc284b595,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

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

impl fidl::endpoints::Proxy for PuppetFactoryProxy {
    type Protocol = PuppetFactoryMarker;

    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 PuppetFactoryProxy {
    /// Create a new Proxy for fuchsia.ui.test.conformance/PuppetFactory.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <PuppetFactoryMarker 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) -> PuppetFactoryEventStream {
        PuppetFactoryEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Spawns a puppet instance, which will own a view created using `view_token`, and
    /// binds `puppet_server` to it.
    pub fn r#create(
        &self,
        mut payload: PuppetCreationArgs,
    ) -> fidl::client::QueryResponseFut<
        PuppetFactoryCreateResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        PuppetFactoryProxyInterface::r#create(self, payload)
    }
}

impl PuppetFactoryProxyInterface for PuppetFactoryProxy {
    type CreateResponseFut = fidl::client::QueryResponseFut<
        PuppetFactoryCreateResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create(&self, mut payload: PuppetCreationArgs) -> Self::CreateResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<PuppetFactoryCreateResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                PuppetFactoryCreateResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4f90811dc284b595,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<PuppetCreationArgs, PuppetFactoryCreateResponse>(
            &mut payload,
            0x4f90811dc284b595,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

/// A Stream of incoming requests for fuchsia.ui.test.conformance/PuppetFactory.
pub struct PuppetFactoryRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for PuppetFactoryRequestStream {
    type Protocol = PuppetFactoryMarker;
    type ControlHandle = PuppetFactoryControlHandle;

    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 {
        PuppetFactoryControlHandle { 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 PuppetFactoryRequestStream {
    type Item = Result<PuppetFactoryRequest, 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 PuppetFactoryRequestStream 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 {
                    0x4f90811dc284b595 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            PuppetCreationArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PuppetCreationArgs>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            PuppetFactoryControlHandle { inner: this.inner.clone() };
                        Ok(PuppetFactoryRequest::Create {
                            payload: req,
                            responder: PuppetFactoryCreateResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <PuppetFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A helper to spawn a puppet instance, which will own a view created with a specific
/// token.
#[derive(Debug)]
pub enum PuppetFactoryRequest {
    /// Spawns a puppet instance, which will own a view created using `view_token`, and
    /// binds `puppet_server` to it.
    Create { payload: PuppetCreationArgs, responder: PuppetFactoryCreateResponder },
}

impl PuppetFactoryRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create(self) -> Option<(PuppetCreationArgs, PuppetFactoryCreateResponder)> {
        if let PuppetFactoryRequest::Create { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

mod internal {
    use super::*;

    impl PuppetCreationArgs {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.focuser {
                return 9;
            }
            if let Some(_) = self.device_pixel_ratio {
                return 8;
            }
            if let Some(_) = self.keyboard_client {
                return 7;
            }
            if let Some(_) = self.flatland_client {
                return 6;
            }
            if let Some(_) = self.keyboard_listener {
                return 5;
            }
            if let Some(_) = self.mouse_listener {
                return 4;
            }
            if let Some(_) = self.touch_listener {
                return 3;
            }
            if let Some(_) = self.view_token {
                return 2;
            }
            if let Some(_) = self.server_end {
                return 1;
            }
            0
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

    impl PuppetEmbedRemoteViewResponse {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.view_creation_token {
                return 2;
            }
            if let Some(_) = self.result {
                return 1;
            }
            0
        }
    }

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }

    impl PuppetFactoryCreateResponse {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.view_ref {
                return 2;
            }
            if let Some(_) = self.result {
                return 1;
            }
            0
        }
    }

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

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

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

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

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

            next_offset += envelope_size;

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

            Ok(())
        }
    }
}