fidl_fuchsia_ui_composition/

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

#[derive(Debug, PartialEq)]
pub struct AllocatorRegisterBufferCollectionRequest {
    pub args: RegisterBufferCollectionArgs,
}

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

/// A typed wrapper for an eventpair, representing the registry endpoint of a buffer collection.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferCollectionExportToken {
    pub value: fidl::EventPair,
}

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

/// A typed wrapper for an eventpair, representing the Image import endpoint of a buffer
/// collection.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferCollectionImportToken {
    pub value: fidl::EventPair,
}

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

#[derive(Debug, PartialEq)]
pub struct ChildViewWatcherGetViewRefResponse {
    pub view_ref: fidl_fuchsia_ui_views::ViewRef,
}

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

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FlatlandCreateFilledRectRequest {
    pub rect_id: ContentId,
}

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

#[derive(Debug, PartialEq)]
pub struct FlatlandCreateImageRequest {
    pub image_id: ContentId,
    pub import_token: BufferCollectionImportToken,
    pub vmo_index: u32,
    pub properties: ImageProperties,
}

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

#[derive(Debug, PartialEq)]
pub struct FlatlandCreateView2Request {
    /// A typed wrapper for a channel, representing the child endpoint of the connection
    /// between two Flatland instances.
    pub token: fidl_fuchsia_ui_views::ViewCreationToken,
    /// The ViewRef to strongly associate with [`token`].
    pub view_identity: fidl_fuchsia_ui_views::ViewIdentityOnCreation,
    /// The protocol endpoints that are strongly bound to the ViewRef in [`view_identity`].
    /// The protocols are bound when the view is created and installed in the view tree.
    pub protocols: ViewBoundProtocols,
    pub parent_viewport_watcher: fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct FlatlandCreateViewRequest {
    pub token: fidl_fuchsia_ui_views::ViewCreationToken,
    pub parent_viewport_watcher: fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct FlatlandCreateViewportRequest {
    pub viewport_id: ContentId,
    /// A typed wrapper for a channel, representing the parent endpoint of the connection
    /// between two Flatland instances.
    pub token: fidl_fuchsia_ui_views::ViewportCreationToken,
    pub properties: ViewportProperties,
    pub child_view_watcher: fidl::endpoints::ServerEnd<ChildViewWatcherMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct FlatlandDisplaySetContentRequest {
    pub token: fidl_fuchsia_ui_views::ViewportCreationToken,
    pub child_view_watcher: fidl::endpoints::ServerEnd<ChildViewWatcherMarker>,
}

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

#[derive(Debug, PartialEq)]
pub struct FlatlandPresentRequest {
    pub args: PresentArgs,
}

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

#[derive(Debug, PartialEq)]
pub struct FlatlandReleaseViewportResponse {
    pub token: fidl_fuchsia_ui_views::ViewportCreationToken,
}

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

#[derive(Debug, PartialEq)]
pub struct FlatlandSetSolidFillRequest {
    pub rect_id: ContentId,
    pub color: ColorRgba,
    pub size: fidl_fuchsia_math::SizeU,
}

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

#[derive(Debug, PartialEq)]
pub struct TrustedFlatlandFactoryCreateFlatlandRequest {
    /// The server end of the [Flatland] protocol to be created.
    pub server_end: fidl::endpoints::ServerEnd<FlatlandMarker>,
    /// The configuration for the new Flatland session. See [TrustedFlatlandConfig] for
    /// details on available options.
    pub config: TrustedFlatlandConfig,
}

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

/// Metadata about the frame rendered by [`GetNextFrame`].
#[derive(Debug, Default, PartialEq)]
pub struct FrameInfo {
    /// The index of the VMO where the requested frame has been rendered. Required.
    pub buffer_id: Option<u32>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// The arguments passed into the [`GetNextFrame`] call. All fields are necessary.
#[derive(Debug, Default, PartialEq)]
pub struct GetNextFrameArgs {
    /// The event that will signal when the requested frame has been rendered. Required.
    pub event: Option<fidl::Event>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// Arguments passed into [`Present`]. All arguments are optional, and if an
/// argument is omitted Flatland will use a reasonable default, specified below.
#[derive(Debug, Default, PartialEq)]
pub struct PresentArgs {
    /// `requested_presentation_time` specifies the time on or after which the client would like the
    /// enqueued operations to take visible effect (light up pixels on the screen), expressed in
    /// nanoseconds in the `CLOCK_MONOTONIC` timebase.
    ///
    /// The default `requested_presentation_time` is 0.
    ///
    /// Using a `requested_presentation_time` in the present or past (such as 0) schedules enqueued
    /// operations to take visible effect as soon as possible, during the next frame to be prepared.
    ///
    /// Using a `requested_presentation_time` in the future schedules the enqueued operations to
    /// take visible effect on or as closely as possible after the stated time, but no earlier.
    ///
    /// Each rendered frame has a target presentation time. This is when Flatland aims to have the
    /// frame presented to the user. Before rendering a frame, Flatland applies all
    /// enqueued operations associated with all squashable calls to [`Present`] whose
    /// `requested_presentation_time` is on or before the frame's target presentation time.
    pub requested_presentation_time: Option<i64>,
    /// Flatland will wait until all of a Flatland instance's `acquire_fences` are ready before it
    /// will execute the presented commands. Not signaling `acquire_fences` will block the current
    /// [`Present`] as well as the following ones even if their `acquire_fences` are signaled.
    ///
    /// The default `acquire_fences` value is the empty vector.
    pub acquire_fences: Option<Vec<fidl::Event>>,
    /// Flatland will signal all `release_fences` when it is safe to reuse resources which no longer
    /// appear in the local scene graph at the time of the current [`Present`].  At the latest, this
    /// will happen when the local scene graph (checkpointed at this [`Present`]) has been
    /// integrated into the global scene graph, and the global scene has been displayed on screen.
    ///
    /// (Under some circumstances, the fences may be signaled earlier, but clients do not need to
    /// worry about this: the fences will only be signaled when it is safe to reuse the associated
    /// resources).
    ///
    /// These fences are intended to manage the reuse of shared memory resources such as sysmem
    /// buffers.  For example, it is undesirable for the client to render into an image which is
    /// currently displayed on screen, because this may result in graphical artifacts such as
    /// tearing.
    ///
    /// It is up to the client to maintain the mapping between each fence and the resources which
    /// will become reusable when the fence is signaled.  A common strategy is to keep track of
    /// resources which were used by the previous [`Present`] but are no longer used by the current
    /// [`Present`].  For example, if an image is removed from the scene by the current [`Present`],
    /// the client would insert a fence here.  When the fence is later signaled, the client knows
    /// that it is safe to render into the image and insert it into the local scene graph in a
    /// subsequent [`Present`].
    ///
    /// If an error occurs, Flatland may close the channel without signaling these fences.  Clients
    /// may immediately release shared buffers, but they should not immediately modify such buffers,
    /// because they may still be displayed on screen.  There is currently no good signal available
    /// to the client about when it is safe to reuse shared buffers.
    ///
    /// The default `release_fences` value is the empty vector.
    pub release_fences: Option<Vec<fidl::Event>>,
    /// If `unsquashable` is true, then the update is guaranteed to be uniquely shown for at
    /// least one vsync interval.
    ///
    /// If `unsquashable` is false, then the update can be combined with those that come after
    /// it.
    ///
    /// If absent, `unsquashable` is false.
    pub unsquashable: Option<bool>,
    /// Flatland will signal all `present_fences` when the frame corresponding to this `Present`
    /// is reported as displayed by the display hardware.  Additionally, each fence will have the
    /// monotonic timestamp of the corresponding vsync written into it.
    ///
    /// The default `present_fences` value is the empty vector.
    pub present_fences: Option<Vec<fidl::Counter>>,
    /// Flatland will signal all `release_counters` when it is safe to reuse resources which no
    /// longer appear in the local scene graph at the time of the current `Present` (i.e. resources
    /// from the previous present). This is similar to `release_fences` but by using counters
    /// instead of events, counters hold the monotonic timestamp of when resources became safe for
    /// reuse. The event based `release_fences` can be used simultaneously with `release_counters`
    /// for resources that don't care about this timestamp.
    ///
    /// The default `release_counters` value is the empty vector.
    pub release_counters: Option<Vec<fidl::Counter>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// The table of arguments for [`RegisterBufferCollection`]. Note that some
/// fields below are REQUIRED.
#[derive(Debug, Default, PartialEq)]
pub struct RegisterBufferCollectionArgs {
    /// Clients can send [`export_token`] to register buffer collections with Allocator to be used
    /// later in [`fuchsia.ui.composition/Flatland`] instances or other Scenic APIs, such as
    /// Screenshot.
    ///
    /// For example, by passing a [`BufferCollectionImportToken`] containing the matching peer of
    /// [`BufferCollectionExportToken`], they can create image resources via
    /// [`fuchsia.ui.composition/Flatland.CreateImage`].
    ///
    /// Clients should wait for the response before using `import_token`.
    ///
    /// This field is REQUIRED.
    pub export_token: Option<BufferCollectionExportToken>,
    pub buffer_collection_token:
        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_sysmem::BufferCollectionTokenMarker>>,
    /// The client can register a buffer collection for various uses, each
    /// coming with their own unique constraints.
    ///
    /// This field is OPTIONAL. If `usage` is omitted it will be treated as if
    /// it has the DEFAULT option.
    ///
    /// # Deprecation
    ///
    /// This arg is deprecated at API version 9 with addition of |usages|.
    ///
    /// If both the `usages` and `usage` fields are set, `usages` takes precedence and `usage` is
    /// ignored.
    pub usage: Option<RegisterBufferCollectionUsage>,
    /// The client can register a buffer collection for various uses and has the ability to
    /// combine usages if multiple are needed.
    ///
    /// This field is OPTIONAL. If `usages` is omitted it will be treated as if
    /// it has only the DEFAULT option.
    pub usages: Option<RegisterBufferCollectionUsages>,
    /// Flatland participates in the allocation of buffers by setting constraints on the
    /// BufferCollection referenced by `buffer_collection_token`. It will not block on buffers
    /// being allocated until the client creates content using the BufferCollection.
    ///
    /// The buffer collection registered with `export_token` is available and kept alive as long
    /// as the client holds a valid [`BufferCollectionImportToken`]. They will be garbage collected
    /// when all [`BufferCollectionImportToken`]s are closed and all the associated Image resources
    /// are released.
    ///
    /// Exactly one of `buffer_collection_token2` / `buffer_collection_token` must be set.
    pub buffer_collection_token2:
        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_sysmem2::BufferCollectionTokenMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// The arguments passed into the [`Configure`] call. Note that not all fields are necessary.
#[derive(Debug, Default, PartialEq)]
pub struct ScreenCaptureConfig {
    /// The import token referencing a BufferCollection registered with
    /// Allocator. Required.
    pub import_token: Option<BufferCollectionImportToken>,
    /// The size of the image in pixels. Required.
    pub size: Option<fidl_fuchsia_math::SizeU>,
    /// The number of buffers in the BufferCollection. Required.
    pub buffer_count: Option<u32>,
    /// The rotation to be applied to the stream of images. Optional; if absent no rotation is
    /// applied.
    pub rotation: Option<Rotation>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct ScreenshotTakeFileRequest {
    /// Format of the requested screenshot.
    pub format: Option<ScreenshotFormat>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct ScreenshotTakeFileResponse {
    /// |fuchsia.io.File| channel used to read the generated screenshot file data.
    /// The server side of the channel is stored on the device until ZX_CHANNEL_PEER_CLOSED
    /// is detected.
    ///
    /// Basic usage: After the client recieves the client end of the file channel,
    /// to avoid memory pile-ups, it should finish reading the data
    /// before calling [`TakeFile`] again. When finished reading,
    /// the client should call [`Close`] on the |fuchsia.io.File| channel, this will release
    /// the memory allocated on the server side.
    pub file: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>>,
    /// Size of the screenshot in pixels.
    pub size: Option<fidl_fuchsia_math::SizeU>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct ScreenshotTakeRequest {
    /// Format of the requested screenshot.
    pub format: Option<ScreenshotFormat>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

#[derive(Debug, Default, PartialEq)]
pub struct ScreenshotTakeResponse {
    /// CPU mappable read-only VMO that contains screenshot data. The server owns the VMO and
    /// may reuse for the next [`Take`]. The VMO is guaranteed to be accessible after mapping.
    /// In some allocations, VMO::read() might not be available, i.e. on emulator.
    ///
    /// Basic usage: After the client receives a VMO handle, to ensure data stability, it should
    /// finish reading the VMO before calling [`Take`] again. When finished reading, the client
    /// should drop the VMO handle.
    ///
    /// Advanced usage: To edit the data, or to persist it beyond the next [`Take`] call, the
    /// client should copy the data to a private VMO.
    pub vmo: Option<fidl::Vmo>,
    /// Size of the screenshot in pixels.
    pub size: Option<fidl_fuchsia_math::SizeU>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// All arguments are optional; default values will be provided if they are absent.
/// By default, the resulting Flatland will behave identically to connecting
/// to the [Flatland] service instead of connecting via the factory.
#[derive(Debug, Default, PartialEq)]
pub struct TrustedFlatlandConfig {
    /// If true and the [PresentArgs.requested_presentation_time] passed to [Flatland.Present] is
    /// set to 0 or less than or equal to the nearest presentation time, a frame will be scheduled
    /// to be presented as soon as all acquire fences are signaled, instead of waiting for other
    /// clients to present within the same vsync. This allows the caller to decide when to wake up
    /// for preparing a frame.
    ///
    /// If [requested_presentation_time] is set to a value greater than the nearest presentation
    /// time, this flag will have no effect and the wakeup time decision will be made by the
    /// scheduler.
    ///
    /// If absent, `schedule_asap` is false.
    pub schedule_asap: Option<bool>,
    /// If true, Scenic should pass acquire fences to the drivers for composition HW, instead of
    /// waiting for them on CPU. This can improve performance by reducing CPU overhead.
    ///
    /// If absent, `pass_acquire_fences` is false.
    pub pass_acquire_fences: Option<bool>,
    /// If true, the client will not utilize Flatland's built in frame-scheduling mechanism and
    /// will ignore present credits, instead relying on their own flow control system.
    ///
    /// If absent, `skips_present_credits` is false.
    pub skips_present_credits: Option<bool>,
    /// If true, the client will not receive [Flatland.OnFramePresented] events.
    ///
    /// If absent, `skips_on_frame_presented` is false.
    pub skips_on_frame_presented: Option<bool>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

/// The protocol endpoints bound to a Flatland ViewCreationToken. These protocols operate on the
/// View that ViewCreationToken created in the Flatland session.
#[derive(Debug, Default, PartialEq)]
pub struct ViewBoundProtocols {
    /// Learn when a View gains focus.
    ///
    /// Server-bound ViewRef. The [`view_ref_focused`] client does not specify the ViewRef
    /// explicitly; instead, the server implementation uses the ViewRef used in View creation for
    /// reporting focus movement on/off this View.
    pub view_ref_focused:
        Option<fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::ViewRefFocusedMarker>>,
    /// Enable a View to request focus transfer to a child (target) View.
    ///
    /// Server-bound ViewRef. The [`view_focuser`] client does not specify the "requestor" ViewRef
    /// explicitly, only the "target" ViewRef. Instead, the server implementation uses the ViewRef
    /// used in View creation as the "requestor" ViewRef.
    pub view_focuser: Option<fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::FocuserMarker>>,
    /// Receive touch events that are associated with a View.
    pub touch_source:
        Option<fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::TouchSourceMarker>>,
    /// Receive mouse events that are associated with a View.
    pub mouse_source:
        Option<fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

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

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

impl fidl::endpoints::ProtocolMarker for AllocatorMarker {
    type Proxy = AllocatorProxy;
    type RequestStream = AllocatorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = AllocatorSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.ui.composition.Allocator";
}
impl fidl::endpoints::DiscoverableProtocolMarker for AllocatorMarker {}
pub type AllocatorRegisterBufferCollectionResult = Result<(), RegisterBufferCollectionError>;

pub trait AllocatorProxyInterface: Send + Sync {
    type RegisterBufferCollectionResponseFut: std::future::Future<Output = Result<AllocatorRegisterBufferCollectionResult, fidl::Error>>
        + Send;
    fn r#register_buffer_collection(
        &self,
        args: RegisterBufferCollectionArgs,
    ) -> Self::RegisterBufferCollectionResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AllocatorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for AllocatorSynchronousProxy {
    type Proxy = AllocatorProxy;
    type Protocol = AllocatorMarker;

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

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

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

    /// A BufferCollection is a set of VMOs created by Sysmem and shared by a number of
    /// participants, one of which is the Flatland Renderer. Some content, such as Images, use a
    /// BufferCollection as their backing memory.
    ///
    /// See [`RegisterBufferCollectionArgs`] for information on each argument.
    pub fn r#register_buffer_collection(
        &self,
        mut args: RegisterBufferCollectionArgs,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<AllocatorRegisterBufferCollectionResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<AllocatorRegisterBufferCollectionRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                RegisterBufferCollectionError,
            >, AllocatorMarker>(
                (&mut args,),
                0x494b7ea578d1061e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for AllocatorProxy {
    type Protocol = AllocatorMarker;

    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 AllocatorProxy {
    /// Create a new Proxy for fuchsia.ui.composition/Allocator.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <AllocatorMarker 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) -> AllocatorEventStream {
        AllocatorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// A BufferCollection is a set of VMOs created by Sysmem and shared by a number of
    /// participants, one of which is the Flatland Renderer. Some content, such as Images, use a
    /// BufferCollection as their backing memory.
    ///
    /// See [`RegisterBufferCollectionArgs`] for information on each argument.
    pub fn r#register_buffer_collection(
        &self,
        mut args: RegisterBufferCollectionArgs,
    ) -> fidl::client::QueryResponseFut<
        AllocatorRegisterBufferCollectionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        AllocatorProxyInterface::r#register_buffer_collection(self, args)
    }
}

impl AllocatorProxyInterface for AllocatorProxy {
    type RegisterBufferCollectionResponseFut = fidl::client::QueryResponseFut<
        AllocatorRegisterBufferCollectionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#register_buffer_collection(
        &self,
        mut args: RegisterBufferCollectionArgs,
    ) -> Self::RegisterBufferCollectionResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<AllocatorRegisterBufferCollectionResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    RegisterBufferCollectionError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x494b7ea578d1061e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            AllocatorRegisterBufferCollectionRequest,
            AllocatorRegisterBufferCollectionResult,
        >(
            (&mut args,),
            0x494b7ea578d1061e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for AllocatorRequestStream {
    type Protocol = AllocatorMarker;
    type ControlHandle = AllocatorControlHandle;

    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 {
        AllocatorControlHandle { 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 AllocatorRequestStream {
    type Item = Result<AllocatorRequest, 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 AllocatorRequestStream 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 {
                    0x494b7ea578d1061e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            AllocatorRegisterBufferCollectionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<AllocatorRegisterBufferCollectionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = AllocatorControlHandle { inner: this.inner.clone() };
                        Ok(AllocatorRequest::RegisterBufferCollection {
                            args: req.args,

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

#[derive(Debug)]
pub enum AllocatorRequest {
    /// A BufferCollection is a set of VMOs created by Sysmem and shared by a number of
    /// participants, one of which is the Flatland Renderer. Some content, such as Images, use a
    /// BufferCollection as their backing memory.
    ///
    /// See [`RegisterBufferCollectionArgs`] for information on each argument.
    RegisterBufferCollection {
        args: RegisterBufferCollectionArgs,
        responder: AllocatorRegisterBufferCollectionResponder,
    },
}

impl AllocatorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_register_buffer_collection(
        self,
    ) -> Option<(RegisterBufferCollectionArgs, AllocatorRegisterBufferCollectionResponder)> {
        if let AllocatorRequest::RegisterBufferCollection { args, responder } = self {
            Some((args, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

impl AllocatorControlHandle {}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ChildViewWatcherMarker {
    type Proxy = ChildViewWatcherProxy;
    type RequestStream = ChildViewWatcherRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ChildViewWatcherSynchronousProxy;

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

pub trait ChildViewWatcherProxyInterface: Send + Sync {
    type GetStatusResponseFut: std::future::Future<Output = Result<ChildViewStatus, fidl::Error>>
        + Send;
    fn r#get_status(&self) -> Self::GetStatusResponseFut;
    type GetViewRefResponseFut: std::future::Future<Output = Result<fidl_fuchsia_ui_views::ViewRef, fidl::Error>>
        + Send;
    fn r#get_view_ref(&self) -> Self::GetViewRefResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ChildViewWatcherSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ChildViewWatcherSynchronousProxy {
    type Proxy = ChildViewWatcherProxy;
    type Protocol = ChildViewWatcherMarker;

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

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

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

    /// A hanging get for receiving the status of a View. This provides information to the parent,
    /// such as whether or not the child has successfully presented content through this View.
    ///
    /// This hanging get will only fire when the ChildViewStatus is different than the previously
    /// returned ChildViewStatus.  This can happen immediately, and even if the creator of the
    /// Viewport hasn't yet called Present() after calling CreateViewport().  This allows the parent
    /// to know that the child has content ready to display before the parent modifies their own
    /// local scene graph to incorporate the child content.
    ///
    /// It is invalid to call `GetStatus` while a previous call is still pending. Doing so will
    /// cause both this channel and the Flatland channel that handed out ChildViewWatcher to be
    /// closed.
    pub fn r#get_status(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ChildViewStatus, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            ChildViewWatcherGetStatusResponse,
            ChildViewWatcherMarker,
        >(
            (),
            0x1d622075f4fc8243,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }

    /// Hanging get to receive the ViewRef of the child View. This will only fire when the View ref
    /// is different from the previously-returned View ref. Note: currently the View ref will not
    /// change after it is first received, but this will change if/when the API changes to allow
    /// relinking of views.
    ///
    /// The ViewRef is not returned until the View is included in the View tree, in other words when
    /// there is a chain of ancestor transforms all the way back up to the root of the scene graph,
    /// i.e. the display.
    ///
    /// It is invalid to call `GetViewRef` while a previous call is still pending. Doing so will
    /// cause both this channel and the Flatland channel that handed out ChildViewWatcher to be
    /// closed.
    ///
    /// A `GetViewRef` call will hang if the View was created using `CreateView`, but returns the
    /// View if the View was created using CreateView2. This is because `CreateView` does not mint
    /// a ViewRef for that View.
    pub fn r#get_view_ref(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_ui_views::ViewRef, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            ChildViewWatcherGetViewRefResponse,
            ChildViewWatcherMarker,
        >(
            (),
            0x3b2f3ca31e8908b4,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.view_ref)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ChildViewWatcherProxy {
    type Protocol = ChildViewWatcherMarker;

    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 ChildViewWatcherProxy {
    /// Create a new Proxy for fuchsia.ui.composition/ChildViewWatcher.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ChildViewWatcherMarker 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) -> ChildViewWatcherEventStream {
        ChildViewWatcherEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// A hanging get for receiving the status of a View. This provides information to the parent,
    /// such as whether or not the child has successfully presented content through this View.
    ///
    /// This hanging get will only fire when the ChildViewStatus is different than the previously
    /// returned ChildViewStatus.  This can happen immediately, and even if the creator of the
    /// Viewport hasn't yet called Present() after calling CreateViewport().  This allows the parent
    /// to know that the child has content ready to display before the parent modifies their own
    /// local scene graph to incorporate the child content.
    ///
    /// It is invalid to call `GetStatus` while a previous call is still pending. Doing so will
    /// cause both this channel and the Flatland channel that handed out ChildViewWatcher to be
    /// closed.
    pub fn r#get_status(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ChildViewStatus,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ChildViewWatcherProxyInterface::r#get_status(self)
    }

    /// Hanging get to receive the ViewRef of the child View. This will only fire when the View ref
    /// is different from the previously-returned View ref. Note: currently the View ref will not
    /// change after it is first received, but this will change if/when the API changes to allow
    /// relinking of views.
    ///
    /// The ViewRef is not returned until the View is included in the View tree, in other words when
    /// there is a chain of ancestor transforms all the way back up to the root of the scene graph,
    /// i.e. the display.
    ///
    /// It is invalid to call `GetViewRef` while a previous call is still pending. Doing so will
    /// cause both this channel and the Flatland channel that handed out ChildViewWatcher to be
    /// closed.
    ///
    /// A `GetViewRef` call will hang if the View was created using `CreateView`, but returns the
    /// View if the View was created using CreateView2. This is because `CreateView` does not mint
    /// a ViewRef for that View.
    pub fn r#get_view_ref(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_ui_views::ViewRef,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ChildViewWatcherProxyInterface::r#get_view_ref(self)
    }
}

impl ChildViewWatcherProxyInterface for ChildViewWatcherProxy {
    type GetStatusResponseFut = fidl::client::QueryResponseFut<
        ChildViewStatus,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_status(&self) -> Self::GetStatusResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ChildViewStatus, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ChildViewWatcherGetStatusResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1d622075f4fc8243,
            >(_buf?)?;
            Ok(_response.status)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ChildViewStatus>(
            (),
            0x1d622075f4fc8243,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ChildViewWatcherRequestStream {
    type Protocol = ChildViewWatcherMarker;
    type ControlHandle = ChildViewWatcherControlHandle;

    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 {
        ChildViewWatcherControlHandle { 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 ChildViewWatcherRequestStream {
    type Item = Result<ChildViewWatcherRequest, 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 ChildViewWatcherRequestStream 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 {
                    0x1d622075f4fc8243 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ChildViewWatcherControlHandle { inner: this.inner.clone() };
                        Ok(ChildViewWatcherRequest::GetStatus {
                            responder: ChildViewWatcherGetStatusResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3b2f3ca31e8908b4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ChildViewWatcherControlHandle { inner: this.inner.clone() };
                        Ok(ChildViewWatcherRequest::GetViewRef {
                            responder: ChildViewWatcherGetViewRefResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ChildViewWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A protocol that provides information about a particular child View which is attached to the
/// Viewport owned by the parent client; connections to this protocol are estabished in
/// [`CreateViewport`].  Since a Flatland instance may contain any number of Viewports, each of
/// which may or may not be attached to a transform, the client can maintain connections to an
/// equal number of ChildViewWatcher instances.
///
/// Each ChildViewWatcher instance will remain connected as long as the corresponding child View
/// exists; the connection will also be closed if the child's ViewCreationToken is dropped without
/// using it to create a View.
#[derive(Debug)]
pub enum ChildViewWatcherRequest {
    /// A hanging get for receiving the status of a View. This provides information to the parent,
    /// such as whether or not the child has successfully presented content through this View.
    ///
    /// This hanging get will only fire when the ChildViewStatus is different than the previously
    /// returned ChildViewStatus.  This can happen immediately, and even if the creator of the
    /// Viewport hasn't yet called Present() after calling CreateViewport().  This allows the parent
    /// to know that the child has content ready to display before the parent modifies their own
    /// local scene graph to incorporate the child content.
    ///
    /// It is invalid to call `GetStatus` while a previous call is still pending. Doing so will
    /// cause both this channel and the Flatland channel that handed out ChildViewWatcher to be
    /// closed.
    GetStatus { responder: ChildViewWatcherGetStatusResponder },
    /// Hanging get to receive the ViewRef of the child View. This will only fire when the View ref
    /// is different from the previously-returned View ref. Note: currently the View ref will not
    /// change after it is first received, but this will change if/when the API changes to allow
    /// relinking of views.
    ///
    /// The ViewRef is not returned until the View is included in the View tree, in other words when
    /// there is a chain of ancestor transforms all the way back up to the root of the scene graph,
    /// i.e. the display.
    ///
    /// It is invalid to call `GetViewRef` while a previous call is still pending. Doing so will
    /// cause both this channel and the Flatland channel that handed out ChildViewWatcher to be
    /// closed.
    ///
    /// A `GetViewRef` call will hang if the View was created using `CreateView`, but returns the
    /// View if the View was created using CreateView2. This is because `CreateView` does not mint
    /// a ViewRef for that View.
    GetViewRef { responder: ChildViewWatcherGetViewRefResponder },
}

impl ChildViewWatcherRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_status(self) -> Option<(ChildViewWatcherGetStatusResponder)> {
        if let ChildViewWatcherRequest::GetStatus { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_view_ref(self) -> Option<(ChildViewWatcherGetViewRefResponder)> {
        if let ChildViewWatcherRequest::GetViewRef { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ChildViewWatcherRequest::GetStatus { .. } => "get_status",
            ChildViewWatcherRequest::GetViewRef { .. } => "get_view_ref",
        }
    }
}

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

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

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

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

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

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

impl ChildViewWatcherControlHandle {}

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

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

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

    fn send_raw(&self, mut status: ChildViewStatus) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ChildViewWatcherGetStatusResponse>(
            (status,),
            self.tx_id,
            0x1d622075f4fc8243,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut view_ref: fidl_fuchsia_ui_views::ViewRef) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ChildViewWatcherGetViewRefResponse>(
            (&mut view_ref,),
            self.tx_id,
            0x3b2f3ca31e8908b4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for FlatlandMarker {
    type Proxy = FlatlandProxy;
    type RequestStream = FlatlandRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = FlatlandSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.ui.composition.Flatland";
}
impl fidl::endpoints::DiscoverableProtocolMarker for FlatlandMarker {}

pub trait FlatlandProxyInterface: Send + Sync {
    fn r#release_image_immediately(&self, image_id: &ContentId) -> Result<(), fidl::Error>;
    fn r#present(&self, args: PresentArgs) -> Result<(), fidl::Error>;
    fn r#create_view(
        &self,
        token: fidl_fuchsia_ui_views::ViewCreationToken,
        parent_viewport_watcher: fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#create_view2(
        &self,
        token: fidl_fuchsia_ui_views::ViewCreationToken,
        view_identity: fidl_fuchsia_ui_views::ViewIdentityOnCreation,
        protocols: ViewBoundProtocols,
        parent_viewport_watcher: fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#create_transform(&self, transform_id: &TransformId) -> Result<(), fidl::Error>;
    fn r#set_translation(
        &self,
        transform_id: &TransformId,
        translation: &fidl_fuchsia_math::Vec_,
    ) -> Result<(), fidl::Error>;
    fn r#set_orientation(
        &self,
        transform_id: &TransformId,
        orientation: Orientation,
    ) -> Result<(), fidl::Error>;
    fn r#set_scale(
        &self,
        transform_id: &TransformId,
        scale: &fidl_fuchsia_math::VecF,
    ) -> Result<(), fidl::Error>;
    fn r#set_opacity(&self, transform_id: &TransformId, value: f32) -> Result<(), fidl::Error>;
    fn r#set_clip_boundary(
        &self,
        transform_id: &TransformId,
        rect: Option<&fidl_fuchsia_math::Rect>,
    ) -> Result<(), fidl::Error>;
    fn r#add_child(
        &self,
        parent_transform_id: &TransformId,
        child_transform_id: &TransformId,
    ) -> Result<(), fidl::Error>;
    fn r#remove_child(
        &self,
        parent_transform_id: &TransformId,
        child_transform_id: &TransformId,
    ) -> Result<(), fidl::Error>;
    fn r#replace_children(
        &self,
        parent_transform_id: &TransformId,
        new_child_transform_ids: &[TransformId],
    ) -> Result<(), fidl::Error>;
    fn r#set_root_transform(&self, transform_id: &TransformId) -> Result<(), fidl::Error>;
    fn r#set_hit_regions(
        &self,
        transform_id: &TransformId,
        regions: &[HitRegion],
    ) -> Result<(), fidl::Error>;
    fn r#set_infinite_hit_region(
        &self,
        transform_id: &TransformId,
        hit_test: HitTestInteraction,
    ) -> Result<(), fidl::Error>;
    fn r#create_viewport(
        &self,
        viewport_id: &ContentId,
        token: fidl_fuchsia_ui_views::ViewportCreationToken,
        properties: &ViewportProperties,
        child_view_watcher: fidl::endpoints::ServerEnd<ChildViewWatcherMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#create_image(
        &self,
        image_id: &ContentId,
        import_token: BufferCollectionImportToken,
        vmo_index: u32,
        properties: &ImageProperties,
    ) -> Result<(), fidl::Error>;
    fn r#set_image_sample_region(
        &self,
        image_id: &ContentId,
        rect: &fidl_fuchsia_math::RectF,
    ) -> Result<(), fidl::Error>;
    fn r#set_image_destination_size(
        &self,
        image_id: &ContentId,
        size: &fidl_fuchsia_math::SizeU,
    ) -> Result<(), fidl::Error>;
    fn r#set_image_blending_function(
        &self,
        image_id: &ContentId,
        blend_mode: BlendMode,
    ) -> Result<(), fidl::Error>;
    fn r#set_image_blend_mode(
        &self,
        image_id: &ContentId,
        blend_mode: BlendMode2,
    ) -> Result<(), fidl::Error>;
    fn r#set_image_opacity(&self, image_id: &ContentId, val: f32) -> Result<(), fidl::Error>;
    fn r#set_image_flip(&self, image_id: &ContentId, flip: ImageFlip) -> Result<(), fidl::Error>;
    fn r#create_filled_rect(&self, rect_id: &ContentId) -> Result<(), fidl::Error>;
    fn r#set_solid_fill(
        &self,
        rect_id: &ContentId,
        color: &ColorRgba,
        size: &fidl_fuchsia_math::SizeU,
    ) -> Result<(), fidl::Error>;
    fn r#release_filled_rect(&self, rect_id: &ContentId) -> Result<(), fidl::Error>;
    fn r#set_content(
        &self,
        transform_id: &TransformId,
        content_id: &ContentId,
    ) -> Result<(), fidl::Error>;
    fn r#set_viewport_properties(
        &self,
        viewport_id: &ContentId,
        properties: &ViewportProperties,
    ) -> Result<(), fidl::Error>;
    fn r#release_transform(&self, transform_id: &TransformId) -> Result<(), fidl::Error>;
    fn r#release_view(&self) -> Result<(), fidl::Error>;
    type ReleaseViewportResponseFut: std::future::Future<
            Output = Result<fidl_fuchsia_ui_views::ViewportCreationToken, fidl::Error>,
        > + Send;
    fn r#release_viewport(&self, viewport_id: &ContentId) -> Self::ReleaseViewportResponseFut;
    fn r#release_image(&self, image_id: &ContentId) -> Result<(), fidl::Error>;
    fn r#clear(&self) -> Result<(), fidl::Error>;
    fn r#set_debug_name(&self, name: &str) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct FlatlandSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for FlatlandSynchronousProxy {
    type Proxy = FlatlandProxy;
    type Protocol = FlatlandMarker;

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

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

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

    /// Releases an image immediately, without waiting for the next present.
    pub fn r#release_image_immediately(&self, mut image_id: &ContentId) -> Result<(), fidl::Error> {
        self.client.send::<TrustedFlatlandReleaseImageImmediatelyRequest>(
            (image_id,),
            0x245e1ac080772c8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Complete execution of all feed-forward operations.
    ///
    /// If executing an operation produces an error (e.g., CreateTransform(0)), an [`OnError`] event
    /// is emitted. Operations that produce errors are ignored and the channel is closed.
    ///
    /// If the execution is completed successfully, [`OnNextFrameBegin`] emits NO_ERROR along
    /// with other valid fields.
    ///
    /// The client may only call [`Present`] when they have a non-zero number of present credits,
    /// which are tracked by the server. The server may increment the number of credits when it
    /// fires the [`OnNextFrameBegin`] event, which informs the client when it receives additional
    /// present credits. Each [`Present`] call uses one present credit and decrements the server
    /// count by one. If the client calls [`Present`] with no present credits, the server will
    /// return a `NO_PRESENTS_REMAINING` error.
    ///
    /// The client should assume that prior to receiving any [`OnNextFrameBegin`] events, they have
    /// one present credit.
    ///
    /// Every [`Present`] call results in one [`OnNextFrameBegin`] event, and one
    /// [`OnFramePresented`] event, typically in that order.
    ///
    /// When the commands flushed by [`Present`] make it to display, an [`OnFramePresented`] event
    /// is fired. This event includes information pertaining to all [`Present`]s that had content
    /// that were part of that frame.
    ///
    /// See [`fuchsia.ui.composition/PresentArgs`] documentation above for more detailed information
    /// on what arguments are passed in and their role.
    pub fn r#present(&self, mut args: PresentArgs) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandPresentRequest>(
            (&mut args,),
            0x50acc2aa1f0acec7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Two Flatland instances may be connected in a parent-child relationship. The parent endpoint
    /// is held in a Viewport, and the child endpoint is held in a View. The parent Flatland
    /// instance that creates a Viewport has control over how the child's View is integrated into
    /// its own View.
    ///
    /// The lifecycle of a parent-child connection starts with two endpoints of a channel object:
    /// a ViewportCreationToken and a ViewCreationToken. Out-of-band protocols pass the
    /// ViewportCreationToken to the parent, which calls [`CreateViewport`], and the
    /// ViewCreationToken to the child, which calls [`CreateView`].
    ///
    /// Only nodes connected to the Root Transform in this Flatland instance will be rendered into
    /// the parent's Viewport.
    ///
    /// Calling [`CreateView`] a second time will disconnect the Root Transform from the existing
    /// parent's Viewport, and attach it to a new parent's Viewport. In other words, each View can
    /// only have one parent.
    ///
    /// This function is queued, meaning that the Root Transform will not be attached to the
    /// parent Viewport until [`Present`] is called. However, clients will receive information
    /// through their ParentViewportWatcher (e.g., LayoutInfo) immediately after calling this
    /// function, even if they have not called [`Present`] or [`SetRootTransform`]. This allows
    /// clients to wait for layout information from their parent before calling [`Present`].
    ///
    /// Any illegal operations on ParentViewportWatcher will cause both ParentViewportWatcher
    /// channel and this Flatland channel to be torn down.
    ///
    /// Lifecycle note. The lifetime of the ParentViewportWatcher channel is bound by the peer
    /// ViewportCreationToken. When the ViewportCreationToken dies, this ParentViewportWatcher
    /// channel is destroyed.
    ///
    /// Views and subgraphs of Views created using `CreateView` will not be represented in the
    /// ViewTree, and hence will not be able to participate in any ViewTree-dependent interactions
    /// such as touch, mouse or focus.
    /// The Flatland protocol provides no way for Views in the subgraph of a View created with
    /// `CreateView` to know that they are excluded from the ViewTree.
    pub fn r#create_view(
        &self,
        mut token: fidl_fuchsia_ui_views::ViewCreationToken,
        mut parent_viewport_watcher: fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandCreateViewRequest>(
            (&mut token, parent_viewport_watcher),
            0x504686eb25864780,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Identical to [`CreateView`], except it allows association of View identity (ViewRef) and
    /// view-bound protocols.
    pub fn r#create_view2(
        &self,
        mut token: fidl_fuchsia_ui_views::ViewCreationToken,
        mut view_identity: fidl_fuchsia_ui_views::ViewIdentityOnCreation,
        mut protocols: ViewBoundProtocols,
        mut parent_viewport_watcher: fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandCreateView2Request>(
            (&mut token, &mut view_identity, &mut protocols, parent_viewport_watcher),
            0x340a3a40c2fdbd5e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Creates a new Transform node. Transforms are a hierarchical piece of a Flatland graph. They
    /// can have children, and can reference Content. A sub-graph represented by a Transform and its
    /// descendants can be rendered to a display.
    ///
    /// Transforms are kept alive, even when released, as long as they are children of either an
    /// unreleased Transform, or the Root Transform.
    ///
    /// Each Transform can have a single piece of attached Content. Common types of Content include
    /// bitmaps, asynchronous streams of images, and Viewports to Views hosted in other Flatland
    /// instances.
    ///
    /// Transforms have attributes. Child Transforms inherit the combined attributes of their
    /// parents. Content attached to a Transform is also affected by that Transform's attributes.
    ///
    /// When a sub-graph of Transforms is rendered, Content will be rendered back-to-front, starting
    /// with the Content on the root transform, and continuing recursively through all of its child
    /// Transforms in the order the children were added. See [`AddChild`] for more information.
    ///
    /// Zero is not a valid transform id. All other values are valid, assuming they are not already
    /// in use (see [`ReleaseTransform`] for more details).
    pub fn r#create_transform(&self, mut transform_id: &TransformId) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandCreateTransformRequest>(
            (transform_id,),
            0x5e042a4d3de3efb0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// All Transform objects support all attributes.
    ///
    /// Geometric attributes are applied in the following order:
    /// 1. Scale (relative to the parent transform's coordinate space)
    /// 2. Orientation (relative to the parent transform's coordinate space)
    /// 3. Translation (relative to the parent transforms's coordinate space,
    ///    unaffected by scale applied to the current transform).
    /// 4. Clipping (relative to the current transform's coordinate space)
    ///
    /// The effects of each of these attributes are cumulative. This means the transform's position
    /// in the view space, and its clip boundary, will be calculated based on that chain of
    /// geometric attributes going up to the root transform.
    ///
    /// For instance, in a nested hierarchy such as the following:
    ///     [Root-Transform -> Transform1 -> Transform2 -> CurrentTransform]
    /// If Transform1 is translated by [2,0] and Transform2 is translated by [0,1] then the
    /// view-space position of CurrentTransform will be [2,1].
    ///
    /// Sets the translation on a Transform. The order of geometric attribute application is
    /// addressed above.
    pub fn r#set_translation(
        &self,
        mut transform_id: &TransformId,
        mut translation: &fidl_fuchsia_math::Vec_,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetTranslationRequest>(
            (transform_id, translation),
            0x7863398291fba346,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the orientation on a Transform. The order of geometric attribute application is
    /// addressed in the documentation for [`SetTranslation`]. In Flatland, the +X axis is
    /// to the right and the +Y axis is down. There is no notion of a Z axis. CCW is defined
    /// from the POV of the user, as if a skeuomorphoic clock is displayed on the screen.
    pub fn r#set_orientation(
        &self,
        mut transform_id: &TransformId,
        mut orientation: Orientation,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetOrientationRequest>(
            (transform_id, orientation),
            0x4915310bc4928edc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the scale on a transform. The order of geometric attribute application is
    /// addressed above. The (x,y) values in the VecF |scale| refer to the scale factor in the
    /// x-axis (width) and y-axis (height) respectively. Scale values must be positive 32-bit
    /// floating point values: https://en.wikipedia.org/wiki/Normal_number_%28computing%29
    pub fn r#set_scale(
        &self,
        mut transform_id: &TransformId,
        mut scale: &fidl_fuchsia_math::VecF,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetScaleRequest>(
            (transform_id, scale),
            0x1ea1766fd8996bb4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets an opacity in linear space to be applied to a transform and its descendents,
    /// which include other transforms and content. Opacity values must be in the range
    /// of [0.0, 1.0], where 0.0 is completely transparent and 1.0 is completely opaque.
    /// Attempting to call this function with values outside that range will result in
    /// an error. A transform's opacity value is multiplied with that of its parent. This
    /// effect works differently from group opacity. Using group opacity, child nodes are
    /// rendered together first, and then have the parent's opacity applied as a post-effect.
    /// Here, opacity is applied to each child individually. This may result in a very
    /// different effect.
    pub fn r#set_opacity(
        &self,
        mut transform_id: &TransformId,
        mut value: f32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetOpacityRequest>(
            (transform_id, value),
            0x3775fc2c00b432fa,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the bounds, expressed in the local coordinate space of the transform, that
    /// constrains the region that content attached to this transform can be rendered to.
    /// If the content's area exceeds the clip bounds, the area outside the bounds will
    /// not be rendered. These bounds are valid for all children of this transform node as
    /// well, which includes nested Flatland instances and their node hierarchies.
    /// If a child transform attempts to set clip bounds larger than that of its parent,
    /// it will be clipped to the parent's clip bounds. The default state is for a transform
    /// to be unclipped, meaning it will not have any bounds placed on its render region.
    /// The clip width/height must be positive. Negative values will result in an error.
    /// Passing in an empty box to the |rect| parameter will remove the clip bounds.
    pub fn r#set_clip_boundary(
        &self,
        mut transform_id: &TransformId,
        mut rect: Option<&fidl_fuchsia_math::Rect>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetClipBoundaryRequest>(
            (transform_id, rect),
            0x6507843df12222d2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Adds a child Transform to a parent Transform. The new child Transform,
    /// and any Content attached to it or its children, will be rendered on top
    /// of the parent's Content, as well as any previously added children.
    ///
    /// The caller must ensure that `child_transform_id` is valid and that there
    /// are no repetitions.  Sending a repeated `child_transform_id` over
    /// multiple calls will result in session closure.
    pub fn r#add_child(
        &self,
        mut parent_transform_id: &TransformId,
        mut child_transform_id: &TransformId,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandAddChildRequest>(
            (parent_transform_id, child_transform_id),
            0x67a8abd2f19b1a74,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Removes a child Transform from a parent Transform.
    pub fn r#remove_child(
        &self,
        mut parent_transform_id: &TransformId,
        mut child_transform_id: &TransformId,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandRemoveChildRequest>(
            (parent_transform_id, child_transform_id),
            0x41d6cd90b298b67a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Removes all child Transforms from a parent Transform and replaces them
    /// with the new child transforms in `new_child_transform_ids`.  The caller
    /// must ensure that all `TransformId` values in `new_child_transform_ids`
    /// are valid and that there are no repetitions.  Sending a repeated
    /// `TransformId` in `new_child_transform_ids` will result in session
    /// closure.
    pub fn r#replace_children(
        &self,
        mut parent_transform_id: &TransformId,
        mut new_child_transform_ids: &[TransformId],
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandReplaceChildrenRequest>(
            (parent_transform_id, new_child_transform_ids),
            0x5b6d86cbbff81316,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the Root Transform for the graph.
    ///
    /// The sub-graph defined by the Root Transform and its children will be rendered as View
    /// in the connected parent's Viewport (see [`CreateView`]). Any parents of the Root Transform
    /// in this Graph will be ignored.
    ///
    /// The Root Transform, and all children of the Root Transform, are kept alive if they are
    /// released (see [`ReleaseTransform`] for more details).
    ///
    /// There is only ever one Root. Since 0 is not a valid transform id (see [`CreateTransform`]),
    /// calling SetRootTransform(0) clears the current Root, destroying any previously released
    /// objects that are not referenced by the new root.
    ///
    /// Note that every View has a clip boundary equivalent to its logical size. Anything outside
    /// that clip boundary will not be rendered. Hence, the Root Transform has a useful coordinate
    /// space of (0, 0) to (logical_size.width, logical_size.height), where (0, 0) is the upper left
    /// corner.
    ///
    /// Setting the root transform installs a full screen hit region on the root transform. Clients
    /// may remove this hit region if they don't want users to be able to interact with the root
    /// transform's content. For additional details on hit regions, see the [`SetHitRegions`]
    /// documentation.
    ///
    /// Default hit region rules
    ///
    ///   A default hit region follows these rules:
    ///   - When [`SetRootTransform`](T) is called, T receives a maximal hit region, covering the
    ///   entire view.
    ///   - If [`SetHitRegions`] is called on T, either before or after [`SetRootTransform`](T),
    ///   then no default hit region is active and the client specified hit regions are used.
    ///   - If a transform is no longer the root transform, i.e., [`SetRootTransform`](U) is
    ///   called, then the original transform no longer has its default hit region.
    ///   - Clients can remove or modify the root transform's hit regions the same way they would
    ///   reset any other transform's hit regions, by calling [`SetHitRegions`] with the appropriate
    ///   vector.
    pub fn r#set_root_transform(&self, mut transform_id: &TransformId) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetRootTransformRequest>(
            (transform_id,),
            0x6e80ca5bcc566cd8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the interactive areas for a Transform. By default, Content is not interactive; hit
    /// regions must be placed for a user to interact with the Content in a View. Because hit
    /// regions are described in the Flatland protocol, a Flatland instance can synchronize Content
    /// and hit regions.
    ///
    /// Each hit region is placed in the coordinate space of the owning Transform, and may or may
    /// not interact with different types of hit testing, depending on its [`HitTestInteraction`]
    /// type. When there are multiple hit regions that intersect with a hit test, the precedence
    /// rules given below dictate which hit region has interacted with the hit test. Only Transforms
    /// that transitively connect to the root Transform have their hit regions interact with a hit
    /// test.
    ///
    /// Calling this function replaces any previous values set on this Transform. To reset a
    /// Transform to "no hit testing": send an empty vector with [`SetHitRegions`].
    ///
    /// Note that root transforms get a default hit region installed by Flatland. For more details,
    /// see the [`SetRootTransform`] documentation.
    ///
    /// Precedence rules
    ///   Within a Transform, if multiple hit regions overlap, the hit test examines each
    ///   intersecting hit region for a possible interaction. Thus, for a regular hit test R and an
    ///   accessibility hit test A, where R and A both intersect two hit regions D ([`DEFAULT`]) and
    ///   S ([`SEMANTICALLY_INVISIBLE`]) on the same Transform, (1) R interacts with both D and S,
    ///   and (2) A only interacts with D. Generally, hit regions that overlap in a single Transform
    ///   can cause confusing behavior.
    ///
    ///   Within a View, for a given hit test, the front-most Transform's hit regions take
    ///   precedence over those behind. This follows the expected reverse "render order" of
    ///   Transforms (described in [`CreateTransform`]), where a user expects to interact with
    ///   Content that is visible, or front-most.
    ///
    ///   Across Flatland instances, for a given hit test, the front-most instance's front-most
    ///   Transform's hit regions take precedence over those behind. This follows the expected
    ///   reverse "render order" of views, where a user expects to interact with the View that is
    ///   visible, or front-most. For example, if a child View owns Content that is rendered over
    ///   the parent View, the user expects to interact with the child's Content.
    pub fn r#set_hit_regions(
        &self,
        mut transform_id: &TransformId,
        mut regions: &[HitRegion],
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetHitRegionsRequest>(
            (transform_id, regions),
            0x31c9d17b07c37ce4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Identical to [`SetHitRegions`], except the hit region associated with [`transform_id`]
    /// covers an infinite region. The hit region is invariant against translation, scaling, and
    /// orientation of the Transform.
    ///
    /// An infinite hit region is still limited in extent by the View's clip boundary, just like a
    /// finite hit region.
    ///
    /// Calling this function replaces any previous values set on this Transform. To reset a
    /// Transform to "no hit testing": send an empty vector with [`SetHitRegions`].
    pub fn r#set_infinite_hit_region(
        &self,
        mut transform_id: &TransformId,
        mut hit_test: HitTestInteraction,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetInfiniteHitRegionRequest>(
            (transform_id, hit_test),
            0x26d81af852d29562,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// The Viewport and View pair, together, represent the connection between two Flatland
    /// instances. The Viewport is created in the parent, and the View is created in the child. The
    /// parent has control over how the child's View is integrated into its own View.
    ///
    /// Any illegal operations on ChildViewWatcher will cause both ChildViewWatcher channel and this
    /// Flatland channel to be torn down.
    ///
    /// `ViewportProperties` must have logical_size set. This is the initial size that will drive
    /// the layout of the child. The logical_size is also used as the default Content size, but
    /// subsequent changes to the logical_size will have no effect on the Content size.
    ///
    /// `ViewportProperties` may have inset field not set. In that case, the default value of
    /// (0, 0, 0, 0) is used.
    ///
    /// The logical_size must have positive X and Y components.
    ///
    /// Zero is not a valid ContentId. All other values are valid, assuming they are not already
    /// in use for another piece of Content (see [`ReleaseViewport`] for more details).
    ///
    /// Lifecycle note. The lifetime of the ChildViewWatcher channel is bound by the peer
    /// ViewCreationToken. When the ViewCreationToken dies, this ChildViewWatcher channel is
    /// destroyed.
    pub fn r#create_viewport(
        &self,
        mut viewport_id: &ContentId,
        mut token: fidl_fuchsia_ui_views::ViewportCreationToken,
        mut properties: &ViewportProperties,
        mut child_view_watcher: fidl::endpoints::ServerEnd<ChildViewWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandCreateViewportRequest>(
            (viewport_id, &mut token, properties, child_view_watcher),
            0x2485fbcab7f943c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// An Image is a bitmap backed by a specific VMO in a BufferCollection.
    ///
    /// Image creation requires an allocated BufferCollection registered with Allocator. This
    /// function will fail unless all clients of the specified BufferCollection have set their
    /// constraints.
    ///
    /// The Image must reference a valid VMO index and must have ImageProperties that fall within
    /// the constraints specified by the backing BufferCollection (i.e. width and height within a
    /// valid range, etc.)
    ///
    /// Zero is not a valid Image id. All other values are valid, assuming they are not already in
    /// use for another piece of Content (see [`ReleaseImage`] for more details).
    pub fn r#create_image(
        &self,
        mut image_id: &ContentId,
        mut import_token: BufferCollectionImportToken,
        mut vmo_index: u32,
        mut properties: &ImageProperties,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandCreateImageRequest>(
            (image_id, &mut import_token, vmo_index, properties),
            0x26fae823c4ebedad,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// This function is used to determine the region (in texel space) of an image that will be used
    /// by Flatland when rendering. The image to be sampled is referenced by [`image_id`] and the
    /// sample region is specified by [`rect`] which itself is comprised of an origin point (x,y) as
    /// well as a width and height, in unnormalized coordinates. It is illegal to call this function
    /// on non-image content, or to sample a region outside of the texel space of the image. In
    /// other words, the region specifed by [`rect`] must not exceed the ranges (0, image_width) and
    /// (0, image_height). If (rect.x + rect.width > image_width) or (rect.y + rect.height >
    /// image_height) or if any of the values are negative, this will result in an error.
    ///
    /// If this method is not called, the default sample region is the rectangle with origin at
    /// (0, 0) and width and height set at ImageProperties from [`CreateImage`].
    pub fn r#set_image_sample_region(
        &self,
        mut image_id: &ContentId,
        mut rect: &fidl_fuchsia_math::RectF,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetImageSampleRegionRequest>(
            (image_id, rect),
            0x8039391d715eb28,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// The content size for an Image is the size of the rectangle in the parent's logical
    /// coordinate space that the image occupies. This combined with the global translation of the
    /// transform it is attached to determines the size and location of where the content is
    /// rendered on the display.
    ///
    /// If this method is not called, the default image destination size is the width and height set
    /// at ImageProperties from [`CreateImage`]. The destination size will be affected by scaling if
    /// [`SetScale`] is used on the attached Transform or its parents.
    pub fn r#set_image_destination_size(
        &self,
        mut image_id: &ContentId,
        mut size: &fidl_fuchsia_math::SizeU,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetImageDestinationSizeRequest>(
            (image_id, size),
            0x766cf99a2ec58446,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Determines the blend function to use when rendering the content specified by
    /// |image_id|. |image_id| must be a valid ContentId associated to a transform through
    /// a call to |CreateImage| or |CreateFilledRect|. For details on the different blend functions
    /// that are available, please refer to the BlendMode enum. If this function is not called, then
    /// the default blendmode is BlendMode::SRC.
    pub fn r#set_image_blending_function(
        &self,
        mut image_id: &ContentId,
        mut blend_mode: BlendMode,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetImageBlendingFunctionRequest>(
            (image_id, blend_mode),
            0x10f5da1356275b7b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Determines the blend function to use when rendering the content specified by
    /// |image_id|. |image_id| must be a valid ContentId associated to a transform through
    /// a call to |CreateImage| or |CreateFilledRect|. For details on the different blend functions
    /// that are available, please refer to the BlendMode2 enum. If this function is not called,
    /// the default blendmode is BlendMode2::REPLACE.
    pub fn r#set_image_blend_mode(
        &self,
        mut image_id: &ContentId,
        mut blend_mode: BlendMode2,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetImageBlendModeRequest>(
            (image_id, blend_mode),
            0x5b1667f130c3de67,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets an opacity in linear space to be applied to a flatland image. Opacity values must
    /// be in the range [0.0, 1.0].
    pub fn r#set_image_opacity(
        &self,
        mut image_id: &ContentId,
        mut val: f32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetImageOpacityRequest>(
            (image_id, val),
            0x2da9e4ef4c2cff6f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the image flip to be applied to a flatland image. This call must be performed after a
    /// successful |CreateImage| call. If an invalid |image_id| is supplied, the channel will be
    /// closed due to FlatlandError::BAD_OPERATION. This flip will be applied to the Image before
    /// parent Transform Orientations. If this function is not called, then the default flip value
    /// is ImageFlip::NONE.
    pub fn r#set_image_flip(
        &self,
        mut image_id: &ContentId,
        mut flip: ImageFlip,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetImageFlipRequest>(
            (image_id, flip),
            0x21b20f2c14aae6bc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Creates a solid-color rectangle. By default a filled-rect does not have a defined
    /// color or size. It is necessary to call |SetSolidFill| to specify a color and size
    /// before a filled rect can be used for rendering. Not doing so will result the
    pub fn r#create_filled_rect(&self, mut rect_id: &ContentId) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandCreateFilledRectRequest>(
            (rect_id,),
            0x5e62355abc1c4c5d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Defines the color and size of a filled rect. |rect_id| must refer to content that
    /// was created via a call to CreateFilledRect. The color is not premultiplied. Color values
    /// must be within the range [0,1] inclusive, and normal 32-bit
    /// floating point values: https://en.wikipedia.org/wiki/Normal_number_%28computing%29. Values
    /// that do not conform to these specifications will cause the channel to close.
    /// The rectangle's top left corner will be at (0, 0) in its transform's coordinate space.
    /// Hence, its bottom right corner will be at (size.width, size.height).
    pub fn r#set_solid_fill(
        &self,
        mut rect_id: &ContentId,
        mut color: &ColorRgba,
        mut size: &fidl_fuchsia_math::SizeU,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetSolidFillRequest>(
            (rect_id, color, size),
            0x32d6ef41e182dfa5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Automatically garbage collects the rectangle when it is no longer needed for
    /// rendering. |rect_id| must have been instantiated with a call to
    /// |CreateFilledRect|. Once released, the ID immediately goes out of scope and is free
    /// to be used again.
    pub fn r#release_filled_rect(&self, mut rect_id: &ContentId) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandReleaseFilledRectRequest>(
            (rect_id,),
            0x7392cabe45618f9b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Setting a piece of Content on a Transform makes that Content visible in the render tree as
    /// long as the Transform is visible from the root Transform. The Content will be rendered
    /// before, and therefore "behind", any Content attached to the descendants of the Transform.
    ///
    /// Because each Transform can have, at most, a single piece of Content on it, calling this
    /// function on a Transform that already has Content will replace that Content.
    ///
    /// A Content may be set on more than one Transform.
    ///
    /// Calling this function with a Content id of 0 will remove any Content currently on the
    /// Transform.
    pub fn r#set_content(
        &self,
        mut transform_id: &TransformId,
        mut content_id: &ContentId,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetContentRequest>(
            (transform_id, content_id),
            0x4ed2cfc0ce130862,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Transforms are usually sufficient to change how Content is presented. Viewports, however,
    /// have special properties that are not part of the Transform hierarchy. Those properties can
    /// be set using this function.
    pub fn r#set_viewport_properties(
        &self,
        mut viewport_id: &ContentId,
        mut properties: &ViewportProperties,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetViewportPropertiesRequest>(
            (viewport_id, properties),
            0x66ab67e9608ddb9f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Released Transforms will be garbage collected by the system once they are no longer
    /// necessary for rendering. For Transforms, this means there is no path from any unreleased
    /// Transform to the newly-released Transform.
    ///
    /// Once released, the id immediately goes out of scope for future function calls and can be
    /// reused when creating new Transforms.
    ///
    /// It is an error to call functions with a released id (unless that id has been reused to
    /// construct a new Transform).
    pub fn r#release_transform(&self, mut transform_id: &TransformId) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandReleaseTransformRequest>(
            (transform_id,),
            0xab9328419451c22,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    /// Releases a Viewport from the scene, even if the Viewport is still connected to a Transform.
    /// Unlike other resources, Viewports are garbage collected by the system during the next
    /// [`Present`] because a removed Viewport is guaranteed to provide no renderable content.
    ///
    /// Use SetContent(transform_id, 0) to clean up references to released Viewports.
    ///
    /// Despite having a return type, this function is still feed-forward like [`CreateView`] and
    /// requires a call to [`Present`] to be executed. The ViewportCreationToken will be returned
    /// after the presented operations have been executed.
    pub fn r#release_viewport(
        &self,
        mut viewport_id: &ContentId,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_ui_views::ViewportCreationToken, fidl::Error> {
        let _response = self.client.send_query::<
            FlatlandReleaseViewportRequest,
            FlatlandReleaseViewportResponse,
            FlatlandMarker,
        >(
            (viewport_id,),
            0xbad474aeb5293f9,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.token)
    }

    /// Released Images will be garbage collected by the system once they are no longer necessary
    /// for rendering. For Images, this means the Image is no longer attached to any Transform and
    /// any pending rendering that references the Image is complete.
    ///
    /// Use SetContent(transform_id, 0) to clean up references to released Images.
    ///
    /// Once released, the id immediately goes out of scope for future function calls and can be
    /// reused when creating new Images.
    ///
    /// It is an error to call functions with a released id (unless that id has been reused to
    /// construct a new Image).
    pub fn r#release_image(&self, mut image_id: &ContentId) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandReleaseImageRequest>(
            (image_id,),
            0xb884ffdbc72c111,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// This function will reset all state on this interface. This includes destroying all existing
    /// View and Viewports without returning the associated Token to the caller.
    pub fn r#clear(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x4ec8817c02828c3e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Set debug name of the current client that can be used by Flatland to print as a prefix to
    /// logs to help client distinguish what is theirs. [`name`] can be an arbitrary string, but the
    /// current process name (see fsl::GetCurrentProcessName()) is a good default.
    pub fn r#set_debug_name(&self, mut name: &str) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetDebugNameRequest>(
            (name,),
            0x46a8b397e68a8888,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for FlatlandProxy {
    type Protocol = FlatlandMarker;

    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 FlatlandProxy {
    /// Create a new Proxy for fuchsia.ui.composition/Flatland.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <FlatlandMarker 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) -> FlatlandEventStream {
        FlatlandEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Releases an image immediately, without waiting for the next present.
    pub fn r#release_image_immediately(&self, mut image_id: &ContentId) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#release_image_immediately(self, image_id)
    }

    /// Complete execution of all feed-forward operations.
    ///
    /// If executing an operation produces an error (e.g., CreateTransform(0)), an [`OnError`] event
    /// is emitted. Operations that produce errors are ignored and the channel is closed.
    ///
    /// If the execution is completed successfully, [`OnNextFrameBegin`] emits NO_ERROR along
    /// with other valid fields.
    ///
    /// The client may only call [`Present`] when they have a non-zero number of present credits,
    /// which are tracked by the server. The server may increment the number of credits when it
    /// fires the [`OnNextFrameBegin`] event, which informs the client when it receives additional
    /// present credits. Each [`Present`] call uses one present credit and decrements the server
    /// count by one. If the client calls [`Present`] with no present credits, the server will
    /// return a `NO_PRESENTS_REMAINING` error.
    ///
    /// The client should assume that prior to receiving any [`OnNextFrameBegin`] events, they have
    /// one present credit.
    ///
    /// Every [`Present`] call results in one [`OnNextFrameBegin`] event, and one
    /// [`OnFramePresented`] event, typically in that order.
    ///
    /// When the commands flushed by [`Present`] make it to display, an [`OnFramePresented`] event
    /// is fired. This event includes information pertaining to all [`Present`]s that had content
    /// that were part of that frame.
    ///
    /// See [`fuchsia.ui.composition/PresentArgs`] documentation above for more detailed information
    /// on what arguments are passed in and their role.
    pub fn r#present(&self, mut args: PresentArgs) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#present(self, args)
    }

    /// Two Flatland instances may be connected in a parent-child relationship. The parent endpoint
    /// is held in a Viewport, and the child endpoint is held in a View. The parent Flatland
    /// instance that creates a Viewport has control over how the child's View is integrated into
    /// its own View.
    ///
    /// The lifecycle of a parent-child connection starts with two endpoints of a channel object:
    /// a ViewportCreationToken and a ViewCreationToken. Out-of-band protocols pass the
    /// ViewportCreationToken to the parent, which calls [`CreateViewport`], and the
    /// ViewCreationToken to the child, which calls [`CreateView`].
    ///
    /// Only nodes connected to the Root Transform in this Flatland instance will be rendered into
    /// the parent's Viewport.
    ///
    /// Calling [`CreateView`] a second time will disconnect the Root Transform from the existing
    /// parent's Viewport, and attach it to a new parent's Viewport. In other words, each View can
    /// only have one parent.
    ///
    /// This function is queued, meaning that the Root Transform will not be attached to the
    /// parent Viewport until [`Present`] is called. However, clients will receive information
    /// through their ParentViewportWatcher (e.g., LayoutInfo) immediately after calling this
    /// function, even if they have not called [`Present`] or [`SetRootTransform`]. This allows
    /// clients to wait for layout information from their parent before calling [`Present`].
    ///
    /// Any illegal operations on ParentViewportWatcher will cause both ParentViewportWatcher
    /// channel and this Flatland channel to be torn down.
    ///
    /// Lifecycle note. The lifetime of the ParentViewportWatcher channel is bound by the peer
    /// ViewportCreationToken. When the ViewportCreationToken dies, this ParentViewportWatcher
    /// channel is destroyed.
    ///
    /// Views and subgraphs of Views created using `CreateView` will not be represented in the
    /// ViewTree, and hence will not be able to participate in any ViewTree-dependent interactions
    /// such as touch, mouse or focus.
    /// The Flatland protocol provides no way for Views in the subgraph of a View created with
    /// `CreateView` to know that they are excluded from the ViewTree.
    pub fn r#create_view(
        &self,
        mut token: fidl_fuchsia_ui_views::ViewCreationToken,
        mut parent_viewport_watcher: fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#create_view(self, token, parent_viewport_watcher)
    }

    /// Identical to [`CreateView`], except it allows association of View identity (ViewRef) and
    /// view-bound protocols.
    pub fn r#create_view2(
        &self,
        mut token: fidl_fuchsia_ui_views::ViewCreationToken,
        mut view_identity: fidl_fuchsia_ui_views::ViewIdentityOnCreation,
        mut protocols: ViewBoundProtocols,
        mut parent_viewport_watcher: fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#create_view2(
            self,
            token,
            view_identity,
            protocols,
            parent_viewport_watcher,
        )
    }

    /// Creates a new Transform node. Transforms are a hierarchical piece of a Flatland graph. They
    /// can have children, and can reference Content. A sub-graph represented by a Transform and its
    /// descendants can be rendered to a display.
    ///
    /// Transforms are kept alive, even when released, as long as they are children of either an
    /// unreleased Transform, or the Root Transform.
    ///
    /// Each Transform can have a single piece of attached Content. Common types of Content include
    /// bitmaps, asynchronous streams of images, and Viewports to Views hosted in other Flatland
    /// instances.
    ///
    /// Transforms have attributes. Child Transforms inherit the combined attributes of their
    /// parents. Content attached to a Transform is also affected by that Transform's attributes.
    ///
    /// When a sub-graph of Transforms is rendered, Content will be rendered back-to-front, starting
    /// with the Content on the root transform, and continuing recursively through all of its child
    /// Transforms in the order the children were added. See [`AddChild`] for more information.
    ///
    /// Zero is not a valid transform id. All other values are valid, assuming they are not already
    /// in use (see [`ReleaseTransform`] for more details).
    pub fn r#create_transform(&self, mut transform_id: &TransformId) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#create_transform(self, transform_id)
    }

    /// All Transform objects support all attributes.
    ///
    /// Geometric attributes are applied in the following order:
    /// 1. Scale (relative to the parent transform's coordinate space)
    /// 2. Orientation (relative to the parent transform's coordinate space)
    /// 3. Translation (relative to the parent transforms's coordinate space,
    ///    unaffected by scale applied to the current transform).
    /// 4. Clipping (relative to the current transform's coordinate space)
    ///
    /// The effects of each of these attributes are cumulative. This means the transform's position
    /// in the view space, and its clip boundary, will be calculated based on that chain of
    /// geometric attributes going up to the root transform.
    ///
    /// For instance, in a nested hierarchy such as the following:
    ///     [Root-Transform -> Transform1 -> Transform2 -> CurrentTransform]
    /// If Transform1 is translated by [2,0] and Transform2 is translated by [0,1] then the
    /// view-space position of CurrentTransform will be [2,1].
    ///
    /// Sets the translation on a Transform. The order of geometric attribute application is
    /// addressed above.
    pub fn r#set_translation(
        &self,
        mut transform_id: &TransformId,
        mut translation: &fidl_fuchsia_math::Vec_,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_translation(self, transform_id, translation)
    }

    /// Sets the orientation on a Transform. The order of geometric attribute application is
    /// addressed in the documentation for [`SetTranslation`]. In Flatland, the +X axis is
    /// to the right and the +Y axis is down. There is no notion of a Z axis. CCW is defined
    /// from the POV of the user, as if a skeuomorphoic clock is displayed on the screen.
    pub fn r#set_orientation(
        &self,
        mut transform_id: &TransformId,
        mut orientation: Orientation,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_orientation(self, transform_id, orientation)
    }

    /// Sets the scale on a transform. The order of geometric attribute application is
    /// addressed above. The (x,y) values in the VecF |scale| refer to the scale factor in the
    /// x-axis (width) and y-axis (height) respectively. Scale values must be positive 32-bit
    /// floating point values: https://en.wikipedia.org/wiki/Normal_number_%28computing%29
    pub fn r#set_scale(
        &self,
        mut transform_id: &TransformId,
        mut scale: &fidl_fuchsia_math::VecF,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_scale(self, transform_id, scale)
    }

    /// Sets an opacity in linear space to be applied to a transform and its descendents,
    /// which include other transforms and content. Opacity values must be in the range
    /// of [0.0, 1.0], where 0.0 is completely transparent and 1.0 is completely opaque.
    /// Attempting to call this function with values outside that range will result in
    /// an error. A transform's opacity value is multiplied with that of its parent. This
    /// effect works differently from group opacity. Using group opacity, child nodes are
    /// rendered together first, and then have the parent's opacity applied as a post-effect.
    /// Here, opacity is applied to each child individually. This may result in a very
    /// different effect.
    pub fn r#set_opacity(
        &self,
        mut transform_id: &TransformId,
        mut value: f32,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_opacity(self, transform_id, value)
    }

    /// Sets the bounds, expressed in the local coordinate space of the transform, that
    /// constrains the region that content attached to this transform can be rendered to.
    /// If the content's area exceeds the clip bounds, the area outside the bounds will
    /// not be rendered. These bounds are valid for all children of this transform node as
    /// well, which includes nested Flatland instances and their node hierarchies.
    /// If a child transform attempts to set clip bounds larger than that of its parent,
    /// it will be clipped to the parent's clip bounds. The default state is for a transform
    /// to be unclipped, meaning it will not have any bounds placed on its render region.
    /// The clip width/height must be positive. Negative values will result in an error.
    /// Passing in an empty box to the |rect| parameter will remove the clip bounds.
    pub fn r#set_clip_boundary(
        &self,
        mut transform_id: &TransformId,
        mut rect: Option<&fidl_fuchsia_math::Rect>,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_clip_boundary(self, transform_id, rect)
    }

    /// Adds a child Transform to a parent Transform. The new child Transform,
    /// and any Content attached to it or its children, will be rendered on top
    /// of the parent's Content, as well as any previously added children.
    ///
    /// The caller must ensure that `child_transform_id` is valid and that there
    /// are no repetitions.  Sending a repeated `child_transform_id` over
    /// multiple calls will result in session closure.
    pub fn r#add_child(
        &self,
        mut parent_transform_id: &TransformId,
        mut child_transform_id: &TransformId,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#add_child(self, parent_transform_id, child_transform_id)
    }

    /// Removes a child Transform from a parent Transform.
    pub fn r#remove_child(
        &self,
        mut parent_transform_id: &TransformId,
        mut child_transform_id: &TransformId,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#remove_child(self, parent_transform_id, child_transform_id)
    }

    /// Removes all child Transforms from a parent Transform and replaces them
    /// with the new child transforms in `new_child_transform_ids`.  The caller
    /// must ensure that all `TransformId` values in `new_child_transform_ids`
    /// are valid and that there are no repetitions.  Sending a repeated
    /// `TransformId` in `new_child_transform_ids` will result in session
    /// closure.
    pub fn r#replace_children(
        &self,
        mut parent_transform_id: &TransformId,
        mut new_child_transform_ids: &[TransformId],
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#replace_children(
            self,
            parent_transform_id,
            new_child_transform_ids,
        )
    }

    /// Sets the Root Transform for the graph.
    ///
    /// The sub-graph defined by the Root Transform and its children will be rendered as View
    /// in the connected parent's Viewport (see [`CreateView`]). Any parents of the Root Transform
    /// in this Graph will be ignored.
    ///
    /// The Root Transform, and all children of the Root Transform, are kept alive if they are
    /// released (see [`ReleaseTransform`] for more details).
    ///
    /// There is only ever one Root. Since 0 is not a valid transform id (see [`CreateTransform`]),
    /// calling SetRootTransform(0) clears the current Root, destroying any previously released
    /// objects that are not referenced by the new root.
    ///
    /// Note that every View has a clip boundary equivalent to its logical size. Anything outside
    /// that clip boundary will not be rendered. Hence, the Root Transform has a useful coordinate
    /// space of (0, 0) to (logical_size.width, logical_size.height), where (0, 0) is the upper left
    /// corner.
    ///
    /// Setting the root transform installs a full screen hit region on the root transform. Clients
    /// may remove this hit region if they don't want users to be able to interact with the root
    /// transform's content. For additional details on hit regions, see the [`SetHitRegions`]
    /// documentation.
    ///
    /// Default hit region rules
    ///
    ///   A default hit region follows these rules:
    ///   - When [`SetRootTransform`](T) is called, T receives a maximal hit region, covering the
    ///   entire view.
    ///   - If [`SetHitRegions`] is called on T, either before or after [`SetRootTransform`](T),
    ///   then no default hit region is active and the client specified hit regions are used.
    ///   - If a transform is no longer the root transform, i.e., [`SetRootTransform`](U) is
    ///   called, then the original transform no longer has its default hit region.
    ///   - Clients can remove or modify the root transform's hit regions the same way they would
    ///   reset any other transform's hit regions, by calling [`SetHitRegions`] with the appropriate
    ///   vector.
    pub fn r#set_root_transform(&self, mut transform_id: &TransformId) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_root_transform(self, transform_id)
    }

    /// Sets the interactive areas for a Transform. By default, Content is not interactive; hit
    /// regions must be placed for a user to interact with the Content in a View. Because hit
    /// regions are described in the Flatland protocol, a Flatland instance can synchronize Content
    /// and hit regions.
    ///
    /// Each hit region is placed in the coordinate space of the owning Transform, and may or may
    /// not interact with different types of hit testing, depending on its [`HitTestInteraction`]
    /// type. When there are multiple hit regions that intersect with a hit test, the precedence
    /// rules given below dictate which hit region has interacted with the hit test. Only Transforms
    /// that transitively connect to the root Transform have their hit regions interact with a hit
    /// test.
    ///
    /// Calling this function replaces any previous values set on this Transform. To reset a
    /// Transform to "no hit testing": send an empty vector with [`SetHitRegions`].
    ///
    /// Note that root transforms get a default hit region installed by Flatland. For more details,
    /// see the [`SetRootTransform`] documentation.
    ///
    /// Precedence rules
    ///   Within a Transform, if multiple hit regions overlap, the hit test examines each
    ///   intersecting hit region for a possible interaction. Thus, for a regular hit test R and an
    ///   accessibility hit test A, where R and A both intersect two hit regions D ([`DEFAULT`]) and
    ///   S ([`SEMANTICALLY_INVISIBLE`]) on the same Transform, (1) R interacts with both D and S,
    ///   and (2) A only interacts with D. Generally, hit regions that overlap in a single Transform
    ///   can cause confusing behavior.
    ///
    ///   Within a View, for a given hit test, the front-most Transform's hit regions take
    ///   precedence over those behind. This follows the expected reverse "render order" of
    ///   Transforms (described in [`CreateTransform`]), where a user expects to interact with
    ///   Content that is visible, or front-most.
    ///
    ///   Across Flatland instances, for a given hit test, the front-most instance's front-most
    ///   Transform's hit regions take precedence over those behind. This follows the expected
    ///   reverse "render order" of views, where a user expects to interact with the View that is
    ///   visible, or front-most. For example, if a child View owns Content that is rendered over
    ///   the parent View, the user expects to interact with the child's Content.
    pub fn r#set_hit_regions(
        &self,
        mut transform_id: &TransformId,
        mut regions: &[HitRegion],
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_hit_regions(self, transform_id, regions)
    }

    /// Identical to [`SetHitRegions`], except the hit region associated with [`transform_id`]
    /// covers an infinite region. The hit region is invariant against translation, scaling, and
    /// orientation of the Transform.
    ///
    /// An infinite hit region is still limited in extent by the View's clip boundary, just like a
    /// finite hit region.
    ///
    /// Calling this function replaces any previous values set on this Transform. To reset a
    /// Transform to "no hit testing": send an empty vector with [`SetHitRegions`].
    pub fn r#set_infinite_hit_region(
        &self,
        mut transform_id: &TransformId,
        mut hit_test: HitTestInteraction,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_infinite_hit_region(self, transform_id, hit_test)
    }

    /// The Viewport and View pair, together, represent the connection between two Flatland
    /// instances. The Viewport is created in the parent, and the View is created in the child. The
    /// parent has control over how the child's View is integrated into its own View.
    ///
    /// Any illegal operations on ChildViewWatcher will cause both ChildViewWatcher channel and this
    /// Flatland channel to be torn down.
    ///
    /// `ViewportProperties` must have logical_size set. This is the initial size that will drive
    /// the layout of the child. The logical_size is also used as the default Content size, but
    /// subsequent changes to the logical_size will have no effect on the Content size.
    ///
    /// `ViewportProperties` may have inset field not set. In that case, the default value of
    /// (0, 0, 0, 0) is used.
    ///
    /// The logical_size must have positive X and Y components.
    ///
    /// Zero is not a valid ContentId. All other values are valid, assuming they are not already
    /// in use for another piece of Content (see [`ReleaseViewport`] for more details).
    ///
    /// Lifecycle note. The lifetime of the ChildViewWatcher channel is bound by the peer
    /// ViewCreationToken. When the ViewCreationToken dies, this ChildViewWatcher channel is
    /// destroyed.
    pub fn r#create_viewport(
        &self,
        mut viewport_id: &ContentId,
        mut token: fidl_fuchsia_ui_views::ViewportCreationToken,
        mut properties: &ViewportProperties,
        mut child_view_watcher: fidl::endpoints::ServerEnd<ChildViewWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#create_viewport(
            self,
            viewport_id,
            token,
            properties,
            child_view_watcher,
        )
    }

    /// An Image is a bitmap backed by a specific VMO in a BufferCollection.
    ///
    /// Image creation requires an allocated BufferCollection registered with Allocator. This
    /// function will fail unless all clients of the specified BufferCollection have set their
    /// constraints.
    ///
    /// The Image must reference a valid VMO index and must have ImageProperties that fall within
    /// the constraints specified by the backing BufferCollection (i.e. width and height within a
    /// valid range, etc.)
    ///
    /// Zero is not a valid Image id. All other values are valid, assuming they are not already in
    /// use for another piece of Content (see [`ReleaseImage`] for more details).
    pub fn r#create_image(
        &self,
        mut image_id: &ContentId,
        mut import_token: BufferCollectionImportToken,
        mut vmo_index: u32,
        mut properties: &ImageProperties,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#create_image(self, image_id, import_token, vmo_index, properties)
    }

    /// This function is used to determine the region (in texel space) of an image that will be used
    /// by Flatland when rendering. The image to be sampled is referenced by [`image_id`] and the
    /// sample region is specified by [`rect`] which itself is comprised of an origin point (x,y) as
    /// well as a width and height, in unnormalized coordinates. It is illegal to call this function
    /// on non-image content, or to sample a region outside of the texel space of the image. In
    /// other words, the region specifed by [`rect`] must not exceed the ranges (0, image_width) and
    /// (0, image_height). If (rect.x + rect.width > image_width) or (rect.y + rect.height >
    /// image_height) or if any of the values are negative, this will result in an error.
    ///
    /// If this method is not called, the default sample region is the rectangle with origin at
    /// (0, 0) and width and height set at ImageProperties from [`CreateImage`].
    pub fn r#set_image_sample_region(
        &self,
        mut image_id: &ContentId,
        mut rect: &fidl_fuchsia_math::RectF,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_image_sample_region(self, image_id, rect)
    }

    /// The content size for an Image is the size of the rectangle in the parent's logical
    /// coordinate space that the image occupies. This combined with the global translation of the
    /// transform it is attached to determines the size and location of where the content is
    /// rendered on the display.
    ///
    /// If this method is not called, the default image destination size is the width and height set
    /// at ImageProperties from [`CreateImage`]. The destination size will be affected by scaling if
    /// [`SetScale`] is used on the attached Transform or its parents.
    pub fn r#set_image_destination_size(
        &self,
        mut image_id: &ContentId,
        mut size: &fidl_fuchsia_math::SizeU,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_image_destination_size(self, image_id, size)
    }

    /// Determines the blend function to use when rendering the content specified by
    /// |image_id|. |image_id| must be a valid ContentId associated to a transform through
    /// a call to |CreateImage| or |CreateFilledRect|. For details on the different blend functions
    /// that are available, please refer to the BlendMode enum. If this function is not called, then
    /// the default blendmode is BlendMode::SRC.
    pub fn r#set_image_blending_function(
        &self,
        mut image_id: &ContentId,
        mut blend_mode: BlendMode,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_image_blending_function(self, image_id, blend_mode)
    }

    /// Determines the blend function to use when rendering the content specified by
    /// |image_id|. |image_id| must be a valid ContentId associated to a transform through
    /// a call to |CreateImage| or |CreateFilledRect|. For details on the different blend functions
    /// that are available, please refer to the BlendMode2 enum. If this function is not called,
    /// the default blendmode is BlendMode2::REPLACE.
    pub fn r#set_image_blend_mode(
        &self,
        mut image_id: &ContentId,
        mut blend_mode: BlendMode2,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_image_blend_mode(self, image_id, blend_mode)
    }

    /// Sets an opacity in linear space to be applied to a flatland image. Opacity values must
    /// be in the range [0.0, 1.0].
    pub fn r#set_image_opacity(
        &self,
        mut image_id: &ContentId,
        mut val: f32,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_image_opacity(self, image_id, val)
    }

    /// Sets the image flip to be applied to a flatland image. This call must be performed after a
    /// successful |CreateImage| call. If an invalid |image_id| is supplied, the channel will be
    /// closed due to FlatlandError::BAD_OPERATION. This flip will be applied to the Image before
    /// parent Transform Orientations. If this function is not called, then the default flip value
    /// is ImageFlip::NONE.
    pub fn r#set_image_flip(
        &self,
        mut image_id: &ContentId,
        mut flip: ImageFlip,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_image_flip(self, image_id, flip)
    }

    /// Creates a solid-color rectangle. By default a filled-rect does not have a defined
    /// color or size. It is necessary to call |SetSolidFill| to specify a color and size
    /// before a filled rect can be used for rendering. Not doing so will result the
    pub fn r#create_filled_rect(&self, mut rect_id: &ContentId) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#create_filled_rect(self, rect_id)
    }

    /// Defines the color and size of a filled rect. |rect_id| must refer to content that
    /// was created via a call to CreateFilledRect. The color is not premultiplied. Color values
    /// must be within the range [0,1] inclusive, and normal 32-bit
    /// floating point values: https://en.wikipedia.org/wiki/Normal_number_%28computing%29. Values
    /// that do not conform to these specifications will cause the channel to close.
    /// The rectangle's top left corner will be at (0, 0) in its transform's coordinate space.
    /// Hence, its bottom right corner will be at (size.width, size.height).
    pub fn r#set_solid_fill(
        &self,
        mut rect_id: &ContentId,
        mut color: &ColorRgba,
        mut size: &fidl_fuchsia_math::SizeU,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_solid_fill(self, rect_id, color, size)
    }

    /// Automatically garbage collects the rectangle when it is no longer needed for
    /// rendering. |rect_id| must have been instantiated with a call to
    /// |CreateFilledRect|. Once released, the ID immediately goes out of scope and is free
    /// to be used again.
    pub fn r#release_filled_rect(&self, mut rect_id: &ContentId) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#release_filled_rect(self, rect_id)
    }

    /// Setting a piece of Content on a Transform makes that Content visible in the render tree as
    /// long as the Transform is visible from the root Transform. The Content will be rendered
    /// before, and therefore "behind", any Content attached to the descendants of the Transform.
    ///
    /// Because each Transform can have, at most, a single piece of Content on it, calling this
    /// function on a Transform that already has Content will replace that Content.
    ///
    /// A Content may be set on more than one Transform.
    ///
    /// Calling this function with a Content id of 0 will remove any Content currently on the
    /// Transform.
    pub fn r#set_content(
        &self,
        mut transform_id: &TransformId,
        mut content_id: &ContentId,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_content(self, transform_id, content_id)
    }

    /// Transforms are usually sufficient to change how Content is presented. Viewports, however,
    /// have special properties that are not part of the Transform hierarchy. Those properties can
    /// be set using this function.
    pub fn r#set_viewport_properties(
        &self,
        mut viewport_id: &ContentId,
        mut properties: &ViewportProperties,
    ) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_viewport_properties(self, viewport_id, properties)
    }

    /// Released Transforms will be garbage collected by the system once they are no longer
    /// necessary for rendering. For Transforms, this means there is no path from any unreleased
    /// Transform to the newly-released Transform.
    ///
    /// Once released, the id immediately goes out of scope for future function calls and can be
    /// reused when creating new Transforms.
    ///
    /// It is an error to call functions with a released id (unless that id has been reused to
    /// construct a new Transform).
    pub fn r#release_transform(&self, mut transform_id: &TransformId) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#release_transform(self, transform_id)
    }

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

    /// Releases a Viewport from the scene, even if the Viewport is still connected to a Transform.
    /// Unlike other resources, Viewports are garbage collected by the system during the next
    /// [`Present`] because a removed Viewport is guaranteed to provide no renderable content.
    ///
    /// Use SetContent(transform_id, 0) to clean up references to released Viewports.
    ///
    /// Despite having a return type, this function is still feed-forward like [`CreateView`] and
    /// requires a call to [`Present`] to be executed. The ViewportCreationToken will be returned
    /// after the presented operations have been executed.
    pub fn r#release_viewport(
        &self,
        mut viewport_id: &ContentId,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_ui_views::ViewportCreationToken,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FlatlandProxyInterface::r#release_viewport(self, viewport_id)
    }

    /// Released Images will be garbage collected by the system once they are no longer necessary
    /// for rendering. For Images, this means the Image is no longer attached to any Transform and
    /// any pending rendering that references the Image is complete.
    ///
    /// Use SetContent(transform_id, 0) to clean up references to released Images.
    ///
    /// Once released, the id immediately goes out of scope for future function calls and can be
    /// reused when creating new Images.
    ///
    /// It is an error to call functions with a released id (unless that id has been reused to
    /// construct a new Image).
    pub fn r#release_image(&self, mut image_id: &ContentId) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#release_image(self, image_id)
    }

    /// This function will reset all state on this interface. This includes destroying all existing
    /// View and Viewports without returning the associated Token to the caller.
    pub fn r#clear(&self) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#clear(self)
    }

    /// Set debug name of the current client that can be used by Flatland to print as a prefix to
    /// logs to help client distinguish what is theirs. [`name`] can be an arbitrary string, but the
    /// current process name (see fsl::GetCurrentProcessName()) is a good default.
    pub fn r#set_debug_name(&self, mut name: &str) -> Result<(), fidl::Error> {
        FlatlandProxyInterface::r#set_debug_name(self, name)
    }
}

impl FlatlandProxyInterface for FlatlandProxy {
    fn r#release_image_immediately(&self, mut image_id: &ContentId) -> Result<(), fidl::Error> {
        self.client.send::<TrustedFlatlandReleaseImageImmediatelyRequest>(
            (image_id,),
            0x245e1ac080772c8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#present(&self, mut args: PresentArgs) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandPresentRequest>(
            (&mut args,),
            0x50acc2aa1f0acec7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#create_view(
        &self,
        mut token: fidl_fuchsia_ui_views::ViewCreationToken,
        mut parent_viewport_watcher: fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandCreateViewRequest>(
            (&mut token, parent_viewport_watcher),
            0x504686eb25864780,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#create_view2(
        &self,
        mut token: fidl_fuchsia_ui_views::ViewCreationToken,
        mut view_identity: fidl_fuchsia_ui_views::ViewIdentityOnCreation,
        mut protocols: ViewBoundProtocols,
        mut parent_viewport_watcher: fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandCreateView2Request>(
            (&mut token, &mut view_identity, &mut protocols, parent_viewport_watcher),
            0x340a3a40c2fdbd5e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#create_transform(&self, mut transform_id: &TransformId) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandCreateTransformRequest>(
            (transform_id,),
            0x5e042a4d3de3efb0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_translation(
        &self,
        mut transform_id: &TransformId,
        mut translation: &fidl_fuchsia_math::Vec_,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetTranslationRequest>(
            (transform_id, translation),
            0x7863398291fba346,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_orientation(
        &self,
        mut transform_id: &TransformId,
        mut orientation: Orientation,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetOrientationRequest>(
            (transform_id, orientation),
            0x4915310bc4928edc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_scale(
        &self,
        mut transform_id: &TransformId,
        mut scale: &fidl_fuchsia_math::VecF,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetScaleRequest>(
            (transform_id, scale),
            0x1ea1766fd8996bb4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_opacity(
        &self,
        mut transform_id: &TransformId,
        mut value: f32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetOpacityRequest>(
            (transform_id, value),
            0x3775fc2c00b432fa,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_clip_boundary(
        &self,
        mut transform_id: &TransformId,
        mut rect: Option<&fidl_fuchsia_math::Rect>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetClipBoundaryRequest>(
            (transform_id, rect),
            0x6507843df12222d2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#add_child(
        &self,
        mut parent_transform_id: &TransformId,
        mut child_transform_id: &TransformId,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandAddChildRequest>(
            (parent_transform_id, child_transform_id),
            0x67a8abd2f19b1a74,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#remove_child(
        &self,
        mut parent_transform_id: &TransformId,
        mut child_transform_id: &TransformId,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandRemoveChildRequest>(
            (parent_transform_id, child_transform_id),
            0x41d6cd90b298b67a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#replace_children(
        &self,
        mut parent_transform_id: &TransformId,
        mut new_child_transform_ids: &[TransformId],
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandReplaceChildrenRequest>(
            (parent_transform_id, new_child_transform_ids),
            0x5b6d86cbbff81316,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_root_transform(&self, mut transform_id: &TransformId) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetRootTransformRequest>(
            (transform_id,),
            0x6e80ca5bcc566cd8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_hit_regions(
        &self,
        mut transform_id: &TransformId,
        mut regions: &[HitRegion],
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetHitRegionsRequest>(
            (transform_id, regions),
            0x31c9d17b07c37ce4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_infinite_hit_region(
        &self,
        mut transform_id: &TransformId,
        mut hit_test: HitTestInteraction,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetInfiniteHitRegionRequest>(
            (transform_id, hit_test),
            0x26d81af852d29562,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#create_viewport(
        &self,
        mut viewport_id: &ContentId,
        mut token: fidl_fuchsia_ui_views::ViewportCreationToken,
        mut properties: &ViewportProperties,
        mut child_view_watcher: fidl::endpoints::ServerEnd<ChildViewWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandCreateViewportRequest>(
            (viewport_id, &mut token, properties, child_view_watcher),
            0x2485fbcab7f943c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#create_image(
        &self,
        mut image_id: &ContentId,
        mut import_token: BufferCollectionImportToken,
        mut vmo_index: u32,
        mut properties: &ImageProperties,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandCreateImageRequest>(
            (image_id, &mut import_token, vmo_index, properties),
            0x26fae823c4ebedad,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_image_sample_region(
        &self,
        mut image_id: &ContentId,
        mut rect: &fidl_fuchsia_math::RectF,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetImageSampleRegionRequest>(
            (image_id, rect),
            0x8039391d715eb28,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_image_destination_size(
        &self,
        mut image_id: &ContentId,
        mut size: &fidl_fuchsia_math::SizeU,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetImageDestinationSizeRequest>(
            (image_id, size),
            0x766cf99a2ec58446,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_image_blending_function(
        &self,
        mut image_id: &ContentId,
        mut blend_mode: BlendMode,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetImageBlendingFunctionRequest>(
            (image_id, blend_mode),
            0x10f5da1356275b7b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_image_blend_mode(
        &self,
        mut image_id: &ContentId,
        mut blend_mode: BlendMode2,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetImageBlendModeRequest>(
            (image_id, blend_mode),
            0x5b1667f130c3de67,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_image_opacity(
        &self,
        mut image_id: &ContentId,
        mut val: f32,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetImageOpacityRequest>(
            (image_id, val),
            0x2da9e4ef4c2cff6f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_image_flip(
        &self,
        mut image_id: &ContentId,
        mut flip: ImageFlip,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetImageFlipRequest>(
            (image_id, flip),
            0x21b20f2c14aae6bc,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#create_filled_rect(&self, mut rect_id: &ContentId) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandCreateFilledRectRequest>(
            (rect_id,),
            0x5e62355abc1c4c5d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_solid_fill(
        &self,
        mut rect_id: &ContentId,
        mut color: &ColorRgba,
        mut size: &fidl_fuchsia_math::SizeU,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetSolidFillRequest>(
            (rect_id, color, size),
            0x32d6ef41e182dfa5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#release_filled_rect(&self, mut rect_id: &ContentId) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandReleaseFilledRectRequest>(
            (rect_id,),
            0x7392cabe45618f9b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_content(
        &self,
        mut transform_id: &TransformId,
        mut content_id: &ContentId,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetContentRequest>(
            (transform_id, content_id),
            0x4ed2cfc0ce130862,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_viewport_properties(
        &self,
        mut viewport_id: &ContentId,
        mut properties: &ViewportProperties,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetViewportPropertiesRequest>(
            (viewport_id, properties),
            0x66ab67e9608ddb9f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#release_transform(&self, mut transform_id: &TransformId) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandReleaseTransformRequest>(
            (transform_id,),
            0xab9328419451c22,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    type ReleaseViewportResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_ui_views::ViewportCreationToken,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#release_viewport(&self, mut viewport_id: &ContentId) -> Self::ReleaseViewportResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_ui_views::ViewportCreationToken, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                FlatlandReleaseViewportResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xbad474aeb5293f9,
            >(_buf?)?;
            Ok(_response.token)
        }
        self.client.send_query_and_decode::<
            FlatlandReleaseViewportRequest,
            fidl_fuchsia_ui_views::ViewportCreationToken,
        >(
            (viewport_id,),
            0xbad474aeb5293f9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#release_image(&self, mut image_id: &ContentId) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandReleaseImageRequest>(
            (image_id,),
            0xb884ffdbc72c111,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

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

    fn r#set_debug_name(&self, mut name: &str) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandSetDebugNameRequest>(
            (name,),
            0x46a8b397e68a8888,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

#[derive(Debug)]
pub enum FlatlandEvent {
    OnNextFrameBegin { values: OnNextFrameBeginValues },
    OnFramePresented { frame_presented_info: fidl_fuchsia_scenic_scheduling::FramePresentedInfo },
    OnError { error: FlatlandError },
}

impl FlatlandEvent {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_next_frame_begin(self) -> Option<OnNextFrameBeginValues> {
        if let FlatlandEvent::OnNextFrameBegin { values } = self { Some((values)) } else { None }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_frame_presented(
        self,
    ) -> Option<fidl_fuchsia_scenic_scheduling::FramePresentedInfo> {
        if let FlatlandEvent::OnFramePresented { frame_presented_info } = self {
            Some((frame_presented_info))
        } else {
            None
        }
    }
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_error(self) -> Option<FlatlandError> {
        if let FlatlandEvent::OnError { error } = self { Some((error)) } else { None }
    }

    /// Decodes a message buffer as a [`FlatlandEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<FlatlandEvent, 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 {
            0x10f69a5cdeece84a => {
                let mut out = fidl::new_empty!(
                    FlatlandOnNextFrameBeginRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandOnNextFrameBeginRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((FlatlandEvent::OnNextFrameBegin { values: out.values }))
            }
            0x56e43e1a5f30216d => {
                let mut out = fidl::new_empty!(
                    FlatlandOnFramePresentedRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandOnFramePresentedRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((FlatlandEvent::OnFramePresented {
                    frame_presented_info: out.frame_presented_info,
                }))
            }
            0x1ebf39e90cd8b8d => {
                let mut out = fidl::new_empty!(
                    FlatlandOnErrorRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandOnErrorRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
                Ok((FlatlandEvent::OnError { error: out.error }))
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <FlatlandMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

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

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

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

impl fidl::endpoints::RequestStream for FlatlandRequestStream {
    type Protocol = FlatlandMarker;
    type ControlHandle = FlatlandControlHandle;

    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 {
        FlatlandControlHandle { 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 FlatlandRequestStream {
    type Item = Result<FlatlandRequest, 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 FlatlandRequestStream 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 {
                    0x245e1ac080772c8 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            TrustedFlatlandReleaseImageImmediatelyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TrustedFlatlandReleaseImageImmediatelyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::ReleaseImageImmediately {
                            image_id: req.image_id,

                            control_handle,
                        })
                    }
                    0x50acc2aa1f0acec7 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandPresentRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandPresentRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::Present { args: req.args, control_handle })
                    }
                    0x504686eb25864780 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandCreateViewRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandCreateViewRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::CreateView {
                            token: req.token,
                            parent_viewport_watcher: req.parent_viewport_watcher,

                            control_handle,
                        })
                    }
                    0x340a3a40c2fdbd5e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandCreateView2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandCreateView2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::CreateView2 {
                            token: req.token,
                            view_identity: req.view_identity,
                            protocols: req.protocols,
                            parent_viewport_watcher: req.parent_viewport_watcher,

                            control_handle,
                        })
                    }
                    0x5e042a4d3de3efb0 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandCreateTransformRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandCreateTransformRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::CreateTransform {
                            transform_id: req.transform_id,

                            control_handle,
                        })
                    }
                    0x7863398291fba346 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetTranslationRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetTranslationRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetTranslation {
                            transform_id: req.transform_id,
                            translation: req.translation,

                            control_handle,
                        })
                    }
                    0x4915310bc4928edc => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetOrientationRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetOrientationRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetOrientation {
                            transform_id: req.transform_id,
                            orientation: req.orientation,

                            control_handle,
                        })
                    }
                    0x1ea1766fd8996bb4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetScaleRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetScaleRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetScale {
                            transform_id: req.transform_id,
                            scale: req.scale,

                            control_handle,
                        })
                    }
                    0x3775fc2c00b432fa => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetOpacityRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetOpacityRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetOpacity {
                            transform_id: req.transform_id,
                            value: req.value,

                            control_handle,
                        })
                    }
                    0x6507843df12222d2 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetClipBoundaryRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetClipBoundaryRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetClipBoundary {
                            transform_id: req.transform_id,
                            rect: req.rect,

                            control_handle,
                        })
                    }
                    0x67a8abd2f19b1a74 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandAddChildRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandAddChildRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::AddChild {
                            parent_transform_id: req.parent_transform_id,
                            child_transform_id: req.child_transform_id,

                            control_handle,
                        })
                    }
                    0x41d6cd90b298b67a => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandRemoveChildRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandRemoveChildRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::RemoveChild {
                            parent_transform_id: req.parent_transform_id,
                            child_transform_id: req.child_transform_id,

                            control_handle,
                        })
                    }
                    0x5b6d86cbbff81316 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandReplaceChildrenRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandReplaceChildrenRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::ReplaceChildren {
                            parent_transform_id: req.parent_transform_id,
                            new_child_transform_ids: req.new_child_transform_ids,

                            control_handle,
                        })
                    }
                    0x6e80ca5bcc566cd8 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetRootTransformRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetRootTransformRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetRootTransform {
                            transform_id: req.transform_id,

                            control_handle,
                        })
                    }
                    0x31c9d17b07c37ce4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetHitRegionsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetHitRegionsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetHitRegions {
                            transform_id: req.transform_id,
                            regions: req.regions,

                            control_handle,
                        })
                    }
                    0x26d81af852d29562 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetInfiniteHitRegionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetInfiniteHitRegionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetInfiniteHitRegion {
                            transform_id: req.transform_id,
                            hit_test: req.hit_test,

                            control_handle,
                        })
                    }
                    0x2485fbcab7f943c => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandCreateViewportRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandCreateViewportRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::CreateViewport {
                            viewport_id: req.viewport_id,
                            token: req.token,
                            properties: req.properties,
                            child_view_watcher: req.child_view_watcher,

                            control_handle,
                        })
                    }
                    0x26fae823c4ebedad => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandCreateImageRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandCreateImageRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::CreateImage {
                            image_id: req.image_id,
                            import_token: req.import_token,
                            vmo_index: req.vmo_index,
                            properties: req.properties,

                            control_handle,
                        })
                    }
                    0x8039391d715eb28 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetImageSampleRegionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetImageSampleRegionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetImageSampleRegion {
                            image_id: req.image_id,
                            rect: req.rect,

                            control_handle,
                        })
                    }
                    0x766cf99a2ec58446 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetImageDestinationSizeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetImageDestinationSizeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetImageDestinationSize {
                            image_id: req.image_id,
                            size: req.size,

                            control_handle,
                        })
                    }
                    0x10f5da1356275b7b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetImageBlendingFunctionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetImageBlendingFunctionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetImageBlendingFunction {
                            image_id: req.image_id,
                            blend_mode: req.blend_mode,

                            control_handle,
                        })
                    }
                    0x5b1667f130c3de67 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetImageBlendModeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetImageBlendModeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetImageBlendMode {
                            image_id: req.image_id,
                            blend_mode: req.blend_mode,

                            control_handle,
                        })
                    }
                    0x2da9e4ef4c2cff6f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetImageOpacityRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetImageOpacityRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetImageOpacity {
                            image_id: req.image_id,
                            val: req.val,

                            control_handle,
                        })
                    }
                    0x21b20f2c14aae6bc => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetImageFlipRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetImageFlipRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetImageFlip {
                            image_id: req.image_id,
                            flip: req.flip,

                            control_handle,
                        })
                    }
                    0x5e62355abc1c4c5d => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandCreateFilledRectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandCreateFilledRectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::CreateFilledRect {
                            rect_id: req.rect_id,

                            control_handle,
                        })
                    }
                    0x32d6ef41e182dfa5 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetSolidFillRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetSolidFillRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetSolidFill {
                            rect_id: req.rect_id,
                            color: req.color,
                            size: req.size,

                            control_handle,
                        })
                    }
                    0x7392cabe45618f9b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandReleaseFilledRectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandReleaseFilledRectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::ReleaseFilledRect {
                            rect_id: req.rect_id,

                            control_handle,
                        })
                    }
                    0x4ed2cfc0ce130862 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetContentRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetContentRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetContent {
                            transform_id: req.transform_id,
                            content_id: req.content_id,

                            control_handle,
                        })
                    }
                    0x66ab67e9608ddb9f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetViewportPropertiesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetViewportPropertiesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetViewportProperties {
                            viewport_id: req.viewport_id,
                            properties: req.properties,

                            control_handle,
                        })
                    }
                    0xab9328419451c22 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandReleaseTransformRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandReleaseTransformRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::ReleaseTransform {
                            transform_id: req.transform_id,

                            control_handle,
                        })
                    }
                    0x5b35aab9baffecae => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::ReleaseView { control_handle })
                    }
                    0xbad474aeb5293f9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandReleaseViewportRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandReleaseViewportRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::ReleaseViewport {
                            viewport_id: req.viewport_id,

                            responder: FlatlandReleaseViewportResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xb884ffdbc72c111 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandReleaseImageRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandReleaseImageRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::ReleaseImage { image_id: req.image_id, control_handle })
                    }
                    0x4ec8817c02828c3e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::Clear { control_handle })
                    }
                    0x46a8b397e68a8888 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandSetDebugNameRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandSetDebugNameRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FlatlandControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandRequest::SetDebugName { name: req.name, control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <FlatlandMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Each Flatland instance contains a Graph, which consists of a set of objects, and the
/// relationships between those objects. The client can specify a subset of those objects
/// (specifically, the directed acyclic graph starting at the root transform) to be presented as
/// content to some kind of output -- usually, a display.
///
/// Flatland Graphs are both hierarchical, and distributed. Graphs from different Flatland instances
/// may be connected together, allowing multiple processes to be involved in authoring content for a
/// particular output.
///
/// All functions in this protocol are feed-forward. The operations they represent are not fully
/// executed until [`Present`] is called.
#[derive(Debug)]
pub enum FlatlandRequest {
    /// Releases an image immediately, without waiting for the next present.
    ReleaseImageImmediately {
        image_id: ContentId,
        control_handle: FlatlandControlHandle,
    },
    /// Complete execution of all feed-forward operations.
    ///
    /// If executing an operation produces an error (e.g., CreateTransform(0)), an [`OnError`] event
    /// is emitted. Operations that produce errors are ignored and the channel is closed.
    ///
    /// If the execution is completed successfully, [`OnNextFrameBegin`] emits NO_ERROR along
    /// with other valid fields.
    ///
    /// The client may only call [`Present`] when they have a non-zero number of present credits,
    /// which are tracked by the server. The server may increment the number of credits when it
    /// fires the [`OnNextFrameBegin`] event, which informs the client when it receives additional
    /// present credits. Each [`Present`] call uses one present credit and decrements the server
    /// count by one. If the client calls [`Present`] with no present credits, the server will
    /// return a `NO_PRESENTS_REMAINING` error.
    ///
    /// The client should assume that prior to receiving any [`OnNextFrameBegin`] events, they have
    /// one present credit.
    ///
    /// Every [`Present`] call results in one [`OnNextFrameBegin`] event, and one
    /// [`OnFramePresented`] event, typically in that order.
    ///
    /// When the commands flushed by [`Present`] make it to display, an [`OnFramePresented`] event
    /// is fired. This event includes information pertaining to all [`Present`]s that had content
    /// that were part of that frame.
    ///
    /// See [`fuchsia.ui.composition/PresentArgs`] documentation above for more detailed information
    /// on what arguments are passed in and their role.
    Present {
        args: PresentArgs,
        control_handle: FlatlandControlHandle,
    },
    /// Two Flatland instances may be connected in a parent-child relationship. The parent endpoint
    /// is held in a Viewport, and the child endpoint is held in a View. The parent Flatland
    /// instance that creates a Viewport has control over how the child's View is integrated into
    /// its own View.
    ///
    /// The lifecycle of a parent-child connection starts with two endpoints of a channel object:
    /// a ViewportCreationToken and a ViewCreationToken. Out-of-band protocols pass the
    /// ViewportCreationToken to the parent, which calls [`CreateViewport`], and the
    /// ViewCreationToken to the child, which calls [`CreateView`].
    ///
    /// Only nodes connected to the Root Transform in this Flatland instance will be rendered into
    /// the parent's Viewport.
    ///
    /// Calling [`CreateView`] a second time will disconnect the Root Transform from the existing
    /// parent's Viewport, and attach it to a new parent's Viewport. In other words, each View can
    /// only have one parent.
    ///
    /// This function is queued, meaning that the Root Transform will not be attached to the
    /// parent Viewport until [`Present`] is called. However, clients will receive information
    /// through their ParentViewportWatcher (e.g., LayoutInfo) immediately after calling this
    /// function, even if they have not called [`Present`] or [`SetRootTransform`]. This allows
    /// clients to wait for layout information from their parent before calling [`Present`].
    ///
    /// Any illegal operations on ParentViewportWatcher will cause both ParentViewportWatcher
    /// channel and this Flatland channel to be torn down.
    ///
    /// Lifecycle note. The lifetime of the ParentViewportWatcher channel is bound by the peer
    /// ViewportCreationToken. When the ViewportCreationToken dies, this ParentViewportWatcher
    /// channel is destroyed.
    ///
    /// Views and subgraphs of Views created using `CreateView` will not be represented in the
    /// ViewTree, and hence will not be able to participate in any ViewTree-dependent interactions
    /// such as touch, mouse or focus.
    /// The Flatland protocol provides no way for Views in the subgraph of a View created with
    /// `CreateView` to know that they are excluded from the ViewTree.
    CreateView {
        token: fidl_fuchsia_ui_views::ViewCreationToken,
        parent_viewport_watcher: fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
        control_handle: FlatlandControlHandle,
    },
    /// Identical to [`CreateView`], except it allows association of View identity (ViewRef) and
    /// view-bound protocols.
    CreateView2 {
        token: fidl_fuchsia_ui_views::ViewCreationToken,
        view_identity: fidl_fuchsia_ui_views::ViewIdentityOnCreation,
        protocols: ViewBoundProtocols,
        parent_viewport_watcher: fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
        control_handle: FlatlandControlHandle,
    },
    /// Creates a new Transform node. Transforms are a hierarchical piece of a Flatland graph. They
    /// can have children, and can reference Content. A sub-graph represented by a Transform and its
    /// descendants can be rendered to a display.
    ///
    /// Transforms are kept alive, even when released, as long as they are children of either an
    /// unreleased Transform, or the Root Transform.
    ///
    /// Each Transform can have a single piece of attached Content. Common types of Content include
    /// bitmaps, asynchronous streams of images, and Viewports to Views hosted in other Flatland
    /// instances.
    ///
    /// Transforms have attributes. Child Transforms inherit the combined attributes of their
    /// parents. Content attached to a Transform is also affected by that Transform's attributes.
    ///
    /// When a sub-graph of Transforms is rendered, Content will be rendered back-to-front, starting
    /// with the Content on the root transform, and continuing recursively through all of its child
    /// Transforms in the order the children were added. See [`AddChild`] for more information.
    ///
    /// Zero is not a valid transform id. All other values are valid, assuming they are not already
    /// in use (see [`ReleaseTransform`] for more details).
    CreateTransform {
        transform_id: TransformId,
        control_handle: FlatlandControlHandle,
    },
    /// All Transform objects support all attributes.
    ///
    /// Geometric attributes are applied in the following order:
    /// 1. Scale (relative to the parent transform's coordinate space)
    /// 2. Orientation (relative to the parent transform's coordinate space)
    /// 3. Translation (relative to the parent transforms's coordinate space,
    ///    unaffected by scale applied to the current transform).
    /// 4. Clipping (relative to the current transform's coordinate space)
    ///
    /// The effects of each of these attributes are cumulative. This means the transform's position
    /// in the view space, and its clip boundary, will be calculated based on that chain of
    /// geometric attributes going up to the root transform.
    ///
    /// For instance, in a nested hierarchy such as the following:
    ///     [Root-Transform -> Transform1 -> Transform2 -> CurrentTransform]
    /// If Transform1 is translated by [2,0] and Transform2 is translated by [0,1] then the
    /// view-space position of CurrentTransform will be [2,1].
    ///
    /// Sets the translation on a Transform. The order of geometric attribute application is
    /// addressed above.
    SetTranslation {
        transform_id: TransformId,
        translation: fidl_fuchsia_math::Vec_,
        control_handle: FlatlandControlHandle,
    },
    /// Sets the orientation on a Transform. The order of geometric attribute application is
    /// addressed in the documentation for [`SetTranslation`]. In Flatland, the +X axis is
    /// to the right and the +Y axis is down. There is no notion of a Z axis. CCW is defined
    /// from the POV of the user, as if a skeuomorphoic clock is displayed on the screen.
    SetOrientation {
        transform_id: TransformId,
        orientation: Orientation,
        control_handle: FlatlandControlHandle,
    },
    /// Sets the scale on a transform. The order of geometric attribute application is
    /// addressed above. The (x,y) values in the VecF |scale| refer to the scale factor in the
    /// x-axis (width) and y-axis (height) respectively. Scale values must be positive 32-bit
    /// floating point values: https://en.wikipedia.org/wiki/Normal_number_%28computing%29
    SetScale {
        transform_id: TransformId,
        scale: fidl_fuchsia_math::VecF,
        control_handle: FlatlandControlHandle,
    },
    /// Sets an opacity in linear space to be applied to a transform and its descendents,
    /// which include other transforms and content. Opacity values must be in the range
    /// of [0.0, 1.0], where 0.0 is completely transparent and 1.0 is completely opaque.
    /// Attempting to call this function with values outside that range will result in
    /// an error. A transform's opacity value is multiplied with that of its parent. This
    /// effect works differently from group opacity. Using group opacity, child nodes are
    /// rendered together first, and then have the parent's opacity applied as a post-effect.
    /// Here, opacity is applied to each child individually. This may result in a very
    /// different effect.
    SetOpacity {
        transform_id: TransformId,
        value: f32,
        control_handle: FlatlandControlHandle,
    },
    /// Sets the bounds, expressed in the local coordinate space of the transform, that
    /// constrains the region that content attached to this transform can be rendered to.
    /// If the content's area exceeds the clip bounds, the area outside the bounds will
    /// not be rendered. These bounds are valid for all children of this transform node as
    /// well, which includes nested Flatland instances and their node hierarchies.
    /// If a child transform attempts to set clip bounds larger than that of its parent,
    /// it will be clipped to the parent's clip bounds. The default state is for a transform
    /// to be unclipped, meaning it will not have any bounds placed on its render region.
    /// The clip width/height must be positive. Negative values will result in an error.
    /// Passing in an empty box to the |rect| parameter will remove the clip bounds.
    SetClipBoundary {
        transform_id: TransformId,
        rect: Option<Box<fidl_fuchsia_math::Rect>>,
        control_handle: FlatlandControlHandle,
    },
    /// Adds a child Transform to a parent Transform. The new child Transform,
    /// and any Content attached to it or its children, will be rendered on top
    /// of the parent's Content, as well as any previously added children.
    ///
    /// The caller must ensure that `child_transform_id` is valid and that there
    /// are no repetitions.  Sending a repeated `child_transform_id` over
    /// multiple calls will result in session closure.
    AddChild {
        parent_transform_id: TransformId,
        child_transform_id: TransformId,
        control_handle: FlatlandControlHandle,
    },
    /// Removes a child Transform from a parent Transform.
    RemoveChild {
        parent_transform_id: TransformId,
        child_transform_id: TransformId,
        control_handle: FlatlandControlHandle,
    },
    /// Removes all child Transforms from a parent Transform and replaces them
    /// with the new child transforms in `new_child_transform_ids`.  The caller
    /// must ensure that all `TransformId` values in `new_child_transform_ids`
    /// are valid and that there are no repetitions.  Sending a repeated
    /// `TransformId` in `new_child_transform_ids` will result in session
    /// closure.
    ReplaceChildren {
        parent_transform_id: TransformId,
        new_child_transform_ids: Vec<TransformId>,
        control_handle: FlatlandControlHandle,
    },
    /// Sets the Root Transform for the graph.
    ///
    /// The sub-graph defined by the Root Transform and its children will be rendered as View
    /// in the connected parent's Viewport (see [`CreateView`]). Any parents of the Root Transform
    /// in this Graph will be ignored.
    ///
    /// The Root Transform, and all children of the Root Transform, are kept alive if they are
    /// released (see [`ReleaseTransform`] for more details).
    ///
    /// There is only ever one Root. Since 0 is not a valid transform id (see [`CreateTransform`]),
    /// calling SetRootTransform(0) clears the current Root, destroying any previously released
    /// objects that are not referenced by the new root.
    ///
    /// Note that every View has a clip boundary equivalent to its logical size. Anything outside
    /// that clip boundary will not be rendered. Hence, the Root Transform has a useful coordinate
    /// space of (0, 0) to (logical_size.width, logical_size.height), where (0, 0) is the upper left
    /// corner.
    ///
    /// Setting the root transform installs a full screen hit region on the root transform. Clients
    /// may remove this hit region if they don't want users to be able to interact with the root
    /// transform's content. For additional details on hit regions, see the [`SetHitRegions`]
    /// documentation.
    ///
    /// Default hit region rules
    ///
    ///   A default hit region follows these rules:
    ///   - When [`SetRootTransform`](T) is called, T receives a maximal hit region, covering the
    ///   entire view.
    ///   - If [`SetHitRegions`] is called on T, either before or after [`SetRootTransform`](T),
    ///   then no default hit region is active and the client specified hit regions are used.
    ///   - If a transform is no longer the root transform, i.e., [`SetRootTransform`](U) is
    ///   called, then the original transform no longer has its default hit region.
    ///   - Clients can remove or modify the root transform's hit regions the same way they would
    ///   reset any other transform's hit regions, by calling [`SetHitRegions`] with the appropriate
    ///   vector.
    SetRootTransform {
        transform_id: TransformId,
        control_handle: FlatlandControlHandle,
    },
    /// Sets the interactive areas for a Transform. By default, Content is not interactive; hit
    /// regions must be placed for a user to interact with the Content in a View. Because hit
    /// regions are described in the Flatland protocol, a Flatland instance can synchronize Content
    /// and hit regions.
    ///
    /// Each hit region is placed in the coordinate space of the owning Transform, and may or may
    /// not interact with different types of hit testing, depending on its [`HitTestInteraction`]
    /// type. When there are multiple hit regions that intersect with a hit test, the precedence
    /// rules given below dictate which hit region has interacted with the hit test. Only Transforms
    /// that transitively connect to the root Transform have their hit regions interact with a hit
    /// test.
    ///
    /// Calling this function replaces any previous values set on this Transform. To reset a
    /// Transform to "no hit testing": send an empty vector with [`SetHitRegions`].
    ///
    /// Note that root transforms get a default hit region installed by Flatland. For more details,
    /// see the [`SetRootTransform`] documentation.
    ///
    /// Precedence rules
    ///   Within a Transform, if multiple hit regions overlap, the hit test examines each
    ///   intersecting hit region for a possible interaction. Thus, for a regular hit test R and an
    ///   accessibility hit test A, where R and A both intersect two hit regions D ([`DEFAULT`]) and
    ///   S ([`SEMANTICALLY_INVISIBLE`]) on the same Transform, (1) R interacts with both D and S,
    ///   and (2) A only interacts with D. Generally, hit regions that overlap in a single Transform
    ///   can cause confusing behavior.
    ///
    ///   Within a View, for a given hit test, the front-most Transform's hit regions take
    ///   precedence over those behind. This follows the expected reverse "render order" of
    ///   Transforms (described in [`CreateTransform`]), where a user expects to interact with
    ///   Content that is visible, or front-most.
    ///
    ///   Across Flatland instances, for a given hit test, the front-most instance's front-most
    ///   Transform's hit regions take precedence over those behind. This follows the expected
    ///   reverse "render order" of views, where a user expects to interact with the View that is
    ///   visible, or front-most. For example, if a child View owns Content that is rendered over
    ///   the parent View, the user expects to interact with the child's Content.
    SetHitRegions {
        transform_id: TransformId,
        regions: Vec<HitRegion>,
        control_handle: FlatlandControlHandle,
    },
    /// Identical to [`SetHitRegions`], except the hit region associated with [`transform_id`]
    /// covers an infinite region. The hit region is invariant against translation, scaling, and
    /// orientation of the Transform.
    ///
    /// An infinite hit region is still limited in extent by the View's clip boundary, just like a
    /// finite hit region.
    ///
    /// Calling this function replaces any previous values set on this Transform. To reset a
    /// Transform to "no hit testing": send an empty vector with [`SetHitRegions`].
    SetInfiniteHitRegion {
        transform_id: TransformId,
        hit_test: HitTestInteraction,
        control_handle: FlatlandControlHandle,
    },
    /// The Viewport and View pair, together, represent the connection between two Flatland
    /// instances. The Viewport is created in the parent, and the View is created in the child. The
    /// parent has control over how the child's View is integrated into its own View.
    ///
    /// Any illegal operations on ChildViewWatcher will cause both ChildViewWatcher channel and this
    /// Flatland channel to be torn down.
    ///
    /// `ViewportProperties` must have logical_size set. This is the initial size that will drive
    /// the layout of the child. The logical_size is also used as the default Content size, but
    /// subsequent changes to the logical_size will have no effect on the Content size.
    ///
    /// `ViewportProperties` may have inset field not set. In that case, the default value of
    /// (0, 0, 0, 0) is used.
    ///
    /// The logical_size must have positive X and Y components.
    ///
    /// Zero is not a valid ContentId. All other values are valid, assuming they are not already
    /// in use for another piece of Content (see [`ReleaseViewport`] for more details).
    ///
    /// Lifecycle note. The lifetime of the ChildViewWatcher channel is bound by the peer
    /// ViewCreationToken. When the ViewCreationToken dies, this ChildViewWatcher channel is
    /// destroyed.
    CreateViewport {
        viewport_id: ContentId,
        token: fidl_fuchsia_ui_views::ViewportCreationToken,
        properties: ViewportProperties,
        child_view_watcher: fidl::endpoints::ServerEnd<ChildViewWatcherMarker>,
        control_handle: FlatlandControlHandle,
    },
    /// An Image is a bitmap backed by a specific VMO in a BufferCollection.
    ///
    /// Image creation requires an allocated BufferCollection registered with Allocator. This
    /// function will fail unless all clients of the specified BufferCollection have set their
    /// constraints.
    ///
    /// The Image must reference a valid VMO index and must have ImageProperties that fall within
    /// the constraints specified by the backing BufferCollection (i.e. width and height within a
    /// valid range, etc.)
    ///
    /// Zero is not a valid Image id. All other values are valid, assuming they are not already in
    /// use for another piece of Content (see [`ReleaseImage`] for more details).
    CreateImage {
        image_id: ContentId,
        import_token: BufferCollectionImportToken,
        vmo_index: u32,
        properties: ImageProperties,
        control_handle: FlatlandControlHandle,
    },
    /// This function is used to determine the region (in texel space) of an image that will be used
    /// by Flatland when rendering. The image to be sampled is referenced by [`image_id`] and the
    /// sample region is specified by [`rect`] which itself is comprised of an origin point (x,y) as
    /// well as a width and height, in unnormalized coordinates. It is illegal to call this function
    /// on non-image content, or to sample a region outside of the texel space of the image. In
    /// other words, the region specifed by [`rect`] must not exceed the ranges (0, image_width) and
    /// (0, image_height). If (rect.x + rect.width > image_width) or (rect.y + rect.height >
    /// image_height) or if any of the values are negative, this will result in an error.
    ///
    /// If this method is not called, the default sample region is the rectangle with origin at
    /// (0, 0) and width and height set at ImageProperties from [`CreateImage`].
    SetImageSampleRegion {
        image_id: ContentId,
        rect: fidl_fuchsia_math::RectF,
        control_handle: FlatlandControlHandle,
    },
    /// The content size for an Image is the size of the rectangle in the parent's logical
    /// coordinate space that the image occupies. This combined with the global translation of the
    /// transform it is attached to determines the size and location of where the content is
    /// rendered on the display.
    ///
    /// If this method is not called, the default image destination size is the width and height set
    /// at ImageProperties from [`CreateImage`]. The destination size will be affected by scaling if
    /// [`SetScale`] is used on the attached Transform or its parents.
    SetImageDestinationSize {
        image_id: ContentId,
        size: fidl_fuchsia_math::SizeU,
        control_handle: FlatlandControlHandle,
    },
    /// Determines the blend function to use when rendering the content specified by
    /// |image_id|. |image_id| must be a valid ContentId associated to a transform through
    /// a call to |CreateImage| or |CreateFilledRect|. For details on the different blend functions
    /// that are available, please refer to the BlendMode enum. If this function is not called, then
    /// the default blendmode is BlendMode::SRC.
    SetImageBlendingFunction {
        image_id: ContentId,
        blend_mode: BlendMode,
        control_handle: FlatlandControlHandle,
    },
    /// Determines the blend function to use when rendering the content specified by
    /// |image_id|. |image_id| must be a valid ContentId associated to a transform through
    /// a call to |CreateImage| or |CreateFilledRect|. For details on the different blend functions
    /// that are available, please refer to the BlendMode2 enum. If this function is not called,
    /// the default blendmode is BlendMode2::REPLACE.
    SetImageBlendMode {
        image_id: ContentId,
        blend_mode: BlendMode2,
        control_handle: FlatlandControlHandle,
    },
    /// Sets an opacity in linear space to be applied to a flatland image. Opacity values must
    /// be in the range [0.0, 1.0].
    SetImageOpacity {
        image_id: ContentId,
        val: f32,
        control_handle: FlatlandControlHandle,
    },
    /// Sets the image flip to be applied to a flatland image. This call must be performed after a
    /// successful |CreateImage| call. If an invalid |image_id| is supplied, the channel will be
    /// closed due to FlatlandError::BAD_OPERATION. This flip will be applied to the Image before
    /// parent Transform Orientations. If this function is not called, then the default flip value
    /// is ImageFlip::NONE.
    SetImageFlip {
        image_id: ContentId,
        flip: ImageFlip,
        control_handle: FlatlandControlHandle,
    },
    /// Creates a solid-color rectangle. By default a filled-rect does not have a defined
    /// color or size. It is necessary to call |SetSolidFill| to specify a color and size
    /// before a filled rect can be used for rendering. Not doing so will result the
    CreateFilledRect {
        rect_id: ContentId,
        control_handle: FlatlandControlHandle,
    },
    /// Defines the color and size of a filled rect. |rect_id| must refer to content that
    /// was created via a call to CreateFilledRect. The color is not premultiplied. Color values
    /// must be within the range [0,1] inclusive, and normal 32-bit
    /// floating point values: https://en.wikipedia.org/wiki/Normal_number_%28computing%29. Values
    /// that do not conform to these specifications will cause the channel to close.
    /// The rectangle's top left corner will be at (0, 0) in its transform's coordinate space.
    /// Hence, its bottom right corner will be at (size.width, size.height).
    SetSolidFill {
        rect_id: ContentId,
        color: ColorRgba,
        size: fidl_fuchsia_math::SizeU,
        control_handle: FlatlandControlHandle,
    },
    /// Automatically garbage collects the rectangle when it is no longer needed for
    /// rendering. |rect_id| must have been instantiated with a call to
    /// |CreateFilledRect|. Once released, the ID immediately goes out of scope and is free
    /// to be used again.
    ReleaseFilledRect {
        rect_id: ContentId,
        control_handle: FlatlandControlHandle,
    },
    /// Setting a piece of Content on a Transform makes that Content visible in the render tree as
    /// long as the Transform is visible from the root Transform. The Content will be rendered
    /// before, and therefore "behind", any Content attached to the descendants of the Transform.
    ///
    /// Because each Transform can have, at most, a single piece of Content on it, calling this
    /// function on a Transform that already has Content will replace that Content.
    ///
    /// A Content may be set on more than one Transform.
    ///
    /// Calling this function with a Content id of 0 will remove any Content currently on the
    /// Transform.
    SetContent {
        transform_id: TransformId,
        content_id: ContentId,
        control_handle: FlatlandControlHandle,
    },
    /// Transforms are usually sufficient to change how Content is presented. Viewports, however,
    /// have special properties that are not part of the Transform hierarchy. Those properties can
    /// be set using this function.
    SetViewportProperties {
        viewport_id: ContentId,
        properties: ViewportProperties,
        control_handle: FlatlandControlHandle,
    },
    /// Released Transforms will be garbage collected by the system once they are no longer
    /// necessary for rendering. For Transforms, this means there is no path from any unreleased
    /// Transform to the newly-released Transform.
    ///
    /// Once released, the id immediately goes out of scope for future function calls and can be
    /// reused when creating new Transforms.
    ///
    /// It is an error to call functions with a released id (unless that id has been reused to
    /// construct a new Transform).
    ReleaseTransform {
        transform_id: TransformId,
        control_handle: FlatlandControlHandle,
    },
    ReleaseView {
        control_handle: FlatlandControlHandle,
    },
    /// Releases a Viewport from the scene, even if the Viewport is still connected to a Transform.
    /// Unlike other resources, Viewports are garbage collected by the system during the next
    /// [`Present`] because a removed Viewport is guaranteed to provide no renderable content.
    ///
    /// Use SetContent(transform_id, 0) to clean up references to released Viewports.
    ///
    /// Despite having a return type, this function is still feed-forward like [`CreateView`] and
    /// requires a call to [`Present`] to be executed. The ViewportCreationToken will be returned
    /// after the presented operations have been executed.
    ReleaseViewport {
        viewport_id: ContentId,
        responder: FlatlandReleaseViewportResponder,
    },
    /// Released Images will be garbage collected by the system once they are no longer necessary
    /// for rendering. For Images, this means the Image is no longer attached to any Transform and
    /// any pending rendering that references the Image is complete.
    ///
    /// Use SetContent(transform_id, 0) to clean up references to released Images.
    ///
    /// Once released, the id immediately goes out of scope for future function calls and can be
    /// reused when creating new Images.
    ///
    /// It is an error to call functions with a released id (unless that id has been reused to
    /// construct a new Image).
    ReleaseImage {
        image_id: ContentId,
        control_handle: FlatlandControlHandle,
    },
    /// This function will reset all state on this interface. This includes destroying all existing
    /// View and Viewports without returning the associated Token to the caller.
    Clear {
        control_handle: FlatlandControlHandle,
    },
    /// Set debug name of the current client that can be used by Flatland to print as a prefix to
    /// logs to help client distinguish what is theirs. [`name`] can be an arbitrary string, but the
    /// current process name (see fsl::GetCurrentProcessName()) is a good default.
    SetDebugName {
        name: String,
        control_handle: FlatlandControlHandle,
    },
}

impl FlatlandRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_release_image_immediately(self) -> Option<(ContentId, FlatlandControlHandle)> {
        if let FlatlandRequest::ReleaseImageImmediately { image_id, control_handle } = self {
            Some((image_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_present(self) -> Option<(PresentArgs, FlatlandControlHandle)> {
        if let FlatlandRequest::Present { args, control_handle } = self {
            Some((args, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_view(
        self,
    ) -> Option<(
        fidl_fuchsia_ui_views::ViewCreationToken,
        fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
        FlatlandControlHandle,
    )> {
        if let FlatlandRequest::CreateView { token, parent_viewport_watcher, control_handle } = self
        {
            Some((token, parent_viewport_watcher, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_view2(
        self,
    ) -> Option<(
        fidl_fuchsia_ui_views::ViewCreationToken,
        fidl_fuchsia_ui_views::ViewIdentityOnCreation,
        ViewBoundProtocols,
        fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
        FlatlandControlHandle,
    )> {
        if let FlatlandRequest::CreateView2 {
            token,
            view_identity,
            protocols,
            parent_viewport_watcher,
            control_handle,
        } = self
        {
            Some((token, view_identity, protocols, parent_viewport_watcher, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_transform(self) -> Option<(TransformId, FlatlandControlHandle)> {
        if let FlatlandRequest::CreateTransform { transform_id, control_handle } = self {
            Some((transform_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_translation(
        self,
    ) -> Option<(TransformId, fidl_fuchsia_math::Vec_, FlatlandControlHandle)> {
        if let FlatlandRequest::SetTranslation { transform_id, translation, control_handle } = self
        {
            Some((transform_id, translation, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_orientation(self) -> Option<(TransformId, Orientation, FlatlandControlHandle)> {
        if let FlatlandRequest::SetOrientation { transform_id, orientation, control_handle } = self
        {
            Some((transform_id, orientation, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_scale(
        self,
    ) -> Option<(TransformId, fidl_fuchsia_math::VecF, FlatlandControlHandle)> {
        if let FlatlandRequest::SetScale { transform_id, scale, control_handle } = self {
            Some((transform_id, scale, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_opacity(self) -> Option<(TransformId, f32, FlatlandControlHandle)> {
        if let FlatlandRequest::SetOpacity { transform_id, value, control_handle } = self {
            Some((transform_id, value, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_clip_boundary(
        self,
    ) -> Option<(TransformId, Option<Box<fidl_fuchsia_math::Rect>>, FlatlandControlHandle)> {
        if let FlatlandRequest::SetClipBoundary { transform_id, rect, control_handle } = self {
            Some((transform_id, rect, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_child(self) -> Option<(TransformId, TransformId, FlatlandControlHandle)> {
        if let FlatlandRequest::AddChild {
            parent_transform_id,
            child_transform_id,
            control_handle,
        } = self
        {
            Some((parent_transform_id, child_transform_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_child(self) -> Option<(TransformId, TransformId, FlatlandControlHandle)> {
        if let FlatlandRequest::RemoveChild {
            parent_transform_id,
            child_transform_id,
            control_handle,
        } = self
        {
            Some((parent_transform_id, child_transform_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_replace_children(
        self,
    ) -> Option<(TransformId, Vec<TransformId>, FlatlandControlHandle)> {
        if let FlatlandRequest::ReplaceChildren {
            parent_transform_id,
            new_child_transform_ids,
            control_handle,
        } = self
        {
            Some((parent_transform_id, new_child_transform_ids, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_root_transform(self) -> Option<(TransformId, FlatlandControlHandle)> {
        if let FlatlandRequest::SetRootTransform { transform_id, control_handle } = self {
            Some((transform_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_hit_regions(
        self,
    ) -> Option<(TransformId, Vec<HitRegion>, FlatlandControlHandle)> {
        if let FlatlandRequest::SetHitRegions { transform_id, regions, control_handle } = self {
            Some((transform_id, regions, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_infinite_hit_region(
        self,
    ) -> Option<(TransformId, HitTestInteraction, FlatlandControlHandle)> {
        if let FlatlandRequest::SetInfiniteHitRegion { transform_id, hit_test, control_handle } =
            self
        {
            Some((transform_id, hit_test, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_viewport(
        self,
    ) -> Option<(
        ContentId,
        fidl_fuchsia_ui_views::ViewportCreationToken,
        ViewportProperties,
        fidl::endpoints::ServerEnd<ChildViewWatcherMarker>,
        FlatlandControlHandle,
    )> {
        if let FlatlandRequest::CreateViewport {
            viewport_id,
            token,
            properties,
            child_view_watcher,
            control_handle,
        } = self
        {
            Some((viewport_id, token, properties, child_view_watcher, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_image(
        self,
    ) -> Option<(ContentId, BufferCollectionImportToken, u32, ImageProperties, FlatlandControlHandle)>
    {
        if let FlatlandRequest::CreateImage {
            image_id,
            import_token,
            vmo_index,
            properties,
            control_handle,
        } = self
        {
            Some((image_id, import_token, vmo_index, properties, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_image_sample_region(
        self,
    ) -> Option<(ContentId, fidl_fuchsia_math::RectF, FlatlandControlHandle)> {
        if let FlatlandRequest::SetImageSampleRegion { image_id, rect, control_handle } = self {
            Some((image_id, rect, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_image_destination_size(
        self,
    ) -> Option<(ContentId, fidl_fuchsia_math::SizeU, FlatlandControlHandle)> {
        if let FlatlandRequest::SetImageDestinationSize { image_id, size, control_handle } = self {
            Some((image_id, size, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_image_blending_function(
        self,
    ) -> Option<(ContentId, BlendMode, FlatlandControlHandle)> {
        if let FlatlandRequest::SetImageBlendingFunction { image_id, blend_mode, control_handle } =
            self
        {
            Some((image_id, blend_mode, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_image_blend_mode(
        self,
    ) -> Option<(ContentId, BlendMode2, FlatlandControlHandle)> {
        if let FlatlandRequest::SetImageBlendMode { image_id, blend_mode, control_handle } = self {
            Some((image_id, blend_mode, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_image_opacity(self) -> Option<(ContentId, f32, FlatlandControlHandle)> {
        if let FlatlandRequest::SetImageOpacity { image_id, val, control_handle } = self {
            Some((image_id, val, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_image_flip(self) -> Option<(ContentId, ImageFlip, FlatlandControlHandle)> {
        if let FlatlandRequest::SetImageFlip { image_id, flip, control_handle } = self {
            Some((image_id, flip, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_filled_rect(self) -> Option<(ContentId, FlatlandControlHandle)> {
        if let FlatlandRequest::CreateFilledRect { rect_id, control_handle } = self {
            Some((rect_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_solid_fill(
        self,
    ) -> Option<(ContentId, ColorRgba, fidl_fuchsia_math::SizeU, FlatlandControlHandle)> {
        if let FlatlandRequest::SetSolidFill { rect_id, color, size, control_handle } = self {
            Some((rect_id, color, size, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_release_filled_rect(self) -> Option<(ContentId, FlatlandControlHandle)> {
        if let FlatlandRequest::ReleaseFilledRect { rect_id, control_handle } = self {
            Some((rect_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_content(self) -> Option<(TransformId, ContentId, FlatlandControlHandle)> {
        if let FlatlandRequest::SetContent { transform_id, content_id, control_handle } = self {
            Some((transform_id, content_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_viewport_properties(
        self,
    ) -> Option<(ContentId, ViewportProperties, FlatlandControlHandle)> {
        if let FlatlandRequest::SetViewportProperties { viewport_id, properties, control_handle } =
            self
        {
            Some((viewport_id, properties, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_release_transform(self) -> Option<(TransformId, FlatlandControlHandle)> {
        if let FlatlandRequest::ReleaseTransform { transform_id, control_handle } = self {
            Some((transform_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_release_view(self) -> Option<(FlatlandControlHandle)> {
        if let FlatlandRequest::ReleaseView { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_release_viewport(self) -> Option<(ContentId, FlatlandReleaseViewportResponder)> {
        if let FlatlandRequest::ReleaseViewport { viewport_id, responder } = self {
            Some((viewport_id, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_release_image(self) -> Option<(ContentId, FlatlandControlHandle)> {
        if let FlatlandRequest::ReleaseImage { image_id, control_handle } = self {
            Some((image_id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_clear(self) -> Option<(FlatlandControlHandle)> {
        if let FlatlandRequest::Clear { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_debug_name(self) -> Option<(String, FlatlandControlHandle)> {
        if let FlatlandRequest::SetDebugName { name, control_handle } = self {
            Some((name, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            FlatlandRequest::ReleaseImageImmediately { .. } => "release_image_immediately",
            FlatlandRequest::Present { .. } => "present",
            FlatlandRequest::CreateView { .. } => "create_view",
            FlatlandRequest::CreateView2 { .. } => "create_view2",
            FlatlandRequest::CreateTransform { .. } => "create_transform",
            FlatlandRequest::SetTranslation { .. } => "set_translation",
            FlatlandRequest::SetOrientation { .. } => "set_orientation",
            FlatlandRequest::SetScale { .. } => "set_scale",
            FlatlandRequest::SetOpacity { .. } => "set_opacity",
            FlatlandRequest::SetClipBoundary { .. } => "set_clip_boundary",
            FlatlandRequest::AddChild { .. } => "add_child",
            FlatlandRequest::RemoveChild { .. } => "remove_child",
            FlatlandRequest::ReplaceChildren { .. } => "replace_children",
            FlatlandRequest::SetRootTransform { .. } => "set_root_transform",
            FlatlandRequest::SetHitRegions { .. } => "set_hit_regions",
            FlatlandRequest::SetInfiniteHitRegion { .. } => "set_infinite_hit_region",
            FlatlandRequest::CreateViewport { .. } => "create_viewport",
            FlatlandRequest::CreateImage { .. } => "create_image",
            FlatlandRequest::SetImageSampleRegion { .. } => "set_image_sample_region",
            FlatlandRequest::SetImageDestinationSize { .. } => "set_image_destination_size",
            FlatlandRequest::SetImageBlendingFunction { .. } => "set_image_blending_function",
            FlatlandRequest::SetImageBlendMode { .. } => "set_image_blend_mode",
            FlatlandRequest::SetImageOpacity { .. } => "set_image_opacity",
            FlatlandRequest::SetImageFlip { .. } => "set_image_flip",
            FlatlandRequest::CreateFilledRect { .. } => "create_filled_rect",
            FlatlandRequest::SetSolidFill { .. } => "set_solid_fill",
            FlatlandRequest::ReleaseFilledRect { .. } => "release_filled_rect",
            FlatlandRequest::SetContent { .. } => "set_content",
            FlatlandRequest::SetViewportProperties { .. } => "set_viewport_properties",
            FlatlandRequest::ReleaseTransform { .. } => "release_transform",
            FlatlandRequest::ReleaseView { .. } => "release_view",
            FlatlandRequest::ReleaseViewport { .. } => "release_viewport",
            FlatlandRequest::ReleaseImage { .. } => "release_image",
            FlatlandRequest::Clear { .. } => "clear",
            FlatlandRequest::SetDebugName { .. } => "set_debug_name",
        }
    }
}

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

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

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

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

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

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

impl FlatlandControlHandle {
    pub fn send_on_next_frame_begin(
        &self,
        mut values: &OnNextFrameBeginValues,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<FlatlandOnNextFrameBeginRequest>(
            (values,),
            0,
            0x10f69a5cdeece84a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_frame_presented(
        &self,
        mut frame_presented_info: &fidl_fuchsia_scenic_scheduling::FramePresentedInfo,
    ) -> Result<(), fidl::Error> {
        self.inner.send::<FlatlandOnFramePresentedRequest>(
            (frame_presented_info,),
            0,
            0x56e43e1a5f30216d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    pub fn send_on_error(&self, mut error: FlatlandError) -> Result<(), fidl::Error> {
        self.inner.send::<FlatlandOnErrorRequest>(
            (error,),
            0,
            0x1ebf39e90cd8b8d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(
        &self,
        mut token: fidl_fuchsia_ui_views::ViewportCreationToken,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<FlatlandReleaseViewportResponse>(
            (&mut token,),
            self.tx_id,
            0xbad474aeb5293f9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for FlatlandDisplayMarker {
    type Proxy = FlatlandDisplayProxy;
    type RequestStream = FlatlandDisplayRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = FlatlandDisplaySynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.ui.composition.FlatlandDisplay";
}
impl fidl::endpoints::DiscoverableProtocolMarker for FlatlandDisplayMarker {}

pub trait FlatlandDisplayProxyInterface: Send + Sync {
    fn r#set_content(
        &self,
        token: fidl_fuchsia_ui_views::ViewportCreationToken,
        child_view_watcher: fidl::endpoints::ServerEnd<ChildViewWatcherMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#set_device_pixel_ratio(
        &self,
        device_pixel_ratio: &fidl_fuchsia_math::VecF,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct FlatlandDisplaySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for FlatlandDisplaySynchronousProxy {
    type Proxy = FlatlandDisplayProxy;
    type Protocol = FlatlandDisplayMarker;

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

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

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

    pub fn r#set_content(
        &self,
        mut token: fidl_fuchsia_ui_views::ViewportCreationToken,
        mut child_view_watcher: fidl::endpoints::ServerEnd<ChildViewWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandDisplaySetContentRequest>(
            (&mut token, child_view_watcher),
            0x6748193a39918298,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the ratio of display's physical pixels to device independent pixels that should be used
    /// for the tree of Flatland content that are attached to this display. See
    /// [`LayoutInfo.device_pixel_ratio`] for details.
    ///
    /// The default value is (1.0, 1.0). The valid values are 1.0 and above.
    pub fn r#set_device_pixel_ratio(
        &self,
        mut device_pixel_ratio: &fidl_fuchsia_math::VecF,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandDisplaySetDevicePixelRatioRequest>(
            (device_pixel_ratio,),
            0x392c3e70cc0a81a4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for FlatlandDisplayProxy {
    type Protocol = FlatlandDisplayMarker;

    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 FlatlandDisplayProxy {
    /// Create a new Proxy for fuchsia.ui.composition/FlatlandDisplay.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <FlatlandDisplayMarker 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) -> FlatlandDisplayEventStream {
        FlatlandDisplayEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#set_content(
        &self,
        mut token: fidl_fuchsia_ui_views::ViewportCreationToken,
        mut child_view_watcher: fidl::endpoints::ServerEnd<ChildViewWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        FlatlandDisplayProxyInterface::r#set_content(self, token, child_view_watcher)
    }

    /// Sets the ratio of display's physical pixels to device independent pixels that should be used
    /// for the tree of Flatland content that are attached to this display. See
    /// [`LayoutInfo.device_pixel_ratio`] for details.
    ///
    /// The default value is (1.0, 1.0). The valid values are 1.0 and above.
    pub fn r#set_device_pixel_ratio(
        &self,
        mut device_pixel_ratio: &fidl_fuchsia_math::VecF,
    ) -> Result<(), fidl::Error> {
        FlatlandDisplayProxyInterface::r#set_device_pixel_ratio(self, device_pixel_ratio)
    }
}

impl FlatlandDisplayProxyInterface for FlatlandDisplayProxy {
    fn r#set_content(
        &self,
        mut token: fidl_fuchsia_ui_views::ViewportCreationToken,
        mut child_view_watcher: fidl::endpoints::ServerEnd<ChildViewWatcherMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandDisplaySetContentRequest>(
            (&mut token, child_view_watcher),
            0x6748193a39918298,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_device_pixel_ratio(
        &self,
        mut device_pixel_ratio: &fidl_fuchsia_math::VecF,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FlatlandDisplaySetDevicePixelRatioRequest>(
            (device_pixel_ratio,),
            0x392c3e70cc0a81a4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for FlatlandDisplayRequestStream {
    type Protocol = FlatlandDisplayMarker;
    type ControlHandle = FlatlandDisplayControlHandle;

    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 {
        FlatlandDisplayControlHandle { 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 FlatlandDisplayRequestStream {
    type Item = Result<FlatlandDisplayRequest, 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 FlatlandDisplayRequestStream 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 {
                    0x6748193a39918298 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandDisplaySetContentRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandDisplaySetContentRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            FlatlandDisplayControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandDisplayRequest::SetContent {
                            token: req.token,
                            child_view_watcher: req.child_view_watcher,

                            control_handle,
                        })
                    }
                    0x392c3e70cc0a81a4 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FlatlandDisplaySetDevicePixelRatioRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FlatlandDisplaySetDevicePixelRatioRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            FlatlandDisplayControlHandle { inner: this.inner.clone() };
                        Ok(FlatlandDisplayRequest::SetDevicePixelRatio {
                            device_pixel_ratio: req.device_pixel_ratio,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <FlatlandDisplayMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// This API connects to the singleton "primary display", and allows a tree of Flatland content to
/// be attached underneath.  Only one FlatlandDisplay client connection is allowed at one time.
#[derive(Debug)]
pub enum FlatlandDisplayRequest {
    SetContent {
        token: fidl_fuchsia_ui_views::ViewportCreationToken,
        child_view_watcher: fidl::endpoints::ServerEnd<ChildViewWatcherMarker>,
        control_handle: FlatlandDisplayControlHandle,
    },
    /// Sets the ratio of display's physical pixels to device independent pixels that should be used
    /// for the tree of Flatland content that are attached to this display. See
    /// [`LayoutInfo.device_pixel_ratio`] for details.
    ///
    /// The default value is (1.0, 1.0). The valid values are 1.0 and above.
    SetDevicePixelRatio {
        device_pixel_ratio: fidl_fuchsia_math::VecF,
        control_handle: FlatlandDisplayControlHandle,
    },
}

impl FlatlandDisplayRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_set_content(
        self,
    ) -> Option<(
        fidl_fuchsia_ui_views::ViewportCreationToken,
        fidl::endpoints::ServerEnd<ChildViewWatcherMarker>,
        FlatlandDisplayControlHandle,
    )> {
        if let FlatlandDisplayRequest::SetContent { token, child_view_watcher, control_handle } =
            self
        {
            Some((token, child_view_watcher, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_device_pixel_ratio(
        self,
    ) -> Option<(fidl_fuchsia_math::VecF, FlatlandDisplayControlHandle)> {
        if let FlatlandDisplayRequest::SetDevicePixelRatio { device_pixel_ratio, control_handle } =
            self
        {
            Some((device_pixel_ratio, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            FlatlandDisplayRequest::SetContent { .. } => "set_content",
            FlatlandDisplayRequest::SetDevicePixelRatio { .. } => "set_device_pixel_ratio",
        }
    }
}

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

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

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

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

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

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

impl FlatlandDisplayControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for ParentViewportWatcherMarker {
    type Proxy = ParentViewportWatcherProxy;
    type RequestStream = ParentViewportWatcherRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ParentViewportWatcherSynchronousProxy;

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

pub trait ParentViewportWatcherProxyInterface: Send + Sync {
    type GetLayoutResponseFut: std::future::Future<Output = Result<LayoutInfo, fidl::Error>> + Send;
    fn r#get_layout(&self) -> Self::GetLayoutResponseFut;
    type GetStatusResponseFut: std::future::Future<Output = Result<ParentViewportStatus, fidl::Error>>
        + Send;
    fn r#get_status(&self) -> Self::GetStatusResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ParentViewportWatcherSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ParentViewportWatcherSynchronousProxy {
    type Proxy = ParentViewportWatcherProxy;
    type Protocol = ParentViewportWatcherMarker;

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

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

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

    /// A hanging get for receiving layout information. Clients may receive layout information
    /// before the ParentViewportWatcher operation has been presented. This allows children to
    /// layout their content before their first call to [`Present`]. In transition cases where two
    /// ParentViewportWatcher channels exist at the same time, both protocol instances will be
    /// receiving different layout information.
    ///
    /// This hanging get will only fire when the LayoutInfo is different than the previously
    /// returned LayoutInfo. Note that, since LayoutInfo is a table, only some fields may have
    /// changed.
    ///
    /// It is invalid to call `GetLayout` while a previous call is still pending. Doing so will
    /// cause both this channel and the Flatland channel that handed out ParentViewportWatcher to be
    /// closed.
    pub fn r#get_layout(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<LayoutInfo, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            ParentViewportWatcherGetLayoutResponse,
            ParentViewportWatcherMarker,
        >(
            (),
            0x3cbe5d9638e032,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.info)
    }

    /// A hanging get for receiving the status of the parent Viewport. This provides global
    /// connectivity information to the child.
    ///
    /// This hanging get will only fire when the ParentViewportStatus is different than the
    /// previously returned ParentViewportStatus.
    ///
    /// It is invalid to call `GetStatus` while a previous call is still pending. Doing so will
    /// cause both this channel and the Flatland channel that handed out ParentViewportWatcher to be
    /// closed.
    pub fn r#get_status(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ParentViewportStatus, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            ParentViewportWatcherGetStatusResponse,
            ParentViewportWatcherMarker,
        >(
            (),
            0x7caa022f050d9ea6,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.status)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ParentViewportWatcherProxy {
    type Protocol = ParentViewportWatcherMarker;

    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 ParentViewportWatcherProxy {
    /// Create a new Proxy for fuchsia.ui.composition/ParentViewportWatcher.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <ParentViewportWatcherMarker 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) -> ParentViewportWatcherEventStream {
        ParentViewportWatcherEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// A hanging get for receiving layout information. Clients may receive layout information
    /// before the ParentViewportWatcher operation has been presented. This allows children to
    /// layout their content before their first call to [`Present`]. In transition cases where two
    /// ParentViewportWatcher channels exist at the same time, both protocol instances will be
    /// receiving different layout information.
    ///
    /// This hanging get will only fire when the LayoutInfo is different than the previously
    /// returned LayoutInfo. Note that, since LayoutInfo is a table, only some fields may have
    /// changed.
    ///
    /// It is invalid to call `GetLayout` while a previous call is still pending. Doing so will
    /// cause both this channel and the Flatland channel that handed out ParentViewportWatcher to be
    /// closed.
    pub fn r#get_layout(
        &self,
    ) -> fidl::client::QueryResponseFut<LayoutInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        ParentViewportWatcherProxyInterface::r#get_layout(self)
    }

    /// A hanging get for receiving the status of the parent Viewport. This provides global
    /// connectivity information to the child.
    ///
    /// This hanging get will only fire when the ParentViewportStatus is different than the
    /// previously returned ParentViewportStatus.
    ///
    /// It is invalid to call `GetStatus` while a previous call is still pending. Doing so will
    /// cause both this channel and the Flatland channel that handed out ParentViewportWatcher to be
    /// closed.
    pub fn r#get_status(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ParentViewportStatus,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ParentViewportWatcherProxyInterface::r#get_status(self)
    }
}

impl ParentViewportWatcherProxyInterface for ParentViewportWatcherProxy {
    type GetLayoutResponseFut =
        fidl::client::QueryResponseFut<LayoutInfo, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_layout(&self) -> Self::GetLayoutResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<LayoutInfo, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ParentViewportWatcherGetLayoutResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3cbe5d9638e032,
            >(_buf?)?;
            Ok(_response.info)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, LayoutInfo>(
            (),
            0x3cbe5d9638e032,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ParentViewportWatcherRequestStream {
    type Protocol = ParentViewportWatcherMarker;
    type ControlHandle = ParentViewportWatcherControlHandle;

    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 {
        ParentViewportWatcherControlHandle { 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 ParentViewportWatcherRequestStream {
    type Item = Result<ParentViewportWatcherRequest, 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 ParentViewportWatcherRequestStream 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 {
                0x3cbe5d9638e032 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = ParentViewportWatcherControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ParentViewportWatcherRequest::GetLayout {
                        responder: ParentViewportWatcherGetLayoutResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x7caa022f050d9ea6 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = ParentViewportWatcherControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(ParentViewportWatcherRequest::GetStatus {
                        responder: ParentViewportWatcherGetStatusResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <ParentViewportWatcherMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// A protocol that provides information about the parent Viewport attached to a Flatland instance's
/// sole View.  Although Flatland instances can have at most one view, it is possible to have
/// multiple ParentViewportWatchers during the brief transition period when replacing the instance's
/// View with another, e.g. via [`CreateView`].  During this period, certain updates may be
/// duplicated and sent to each ParentViewportWatcher connection.
///
/// A ParentViewportWatcher will remain connected as long as the corresponding parent Viewport
/// exists; the connection will also be closed if the parents's ViewportCreationToken is dropped
/// without using it to create a Viewport.
#[derive(Debug)]
pub enum ParentViewportWatcherRequest {
    /// A hanging get for receiving layout information. Clients may receive layout information
    /// before the ParentViewportWatcher operation has been presented. This allows children to
    /// layout their content before their first call to [`Present`]. In transition cases where two
    /// ParentViewportWatcher channels exist at the same time, both protocol instances will be
    /// receiving different layout information.
    ///
    /// This hanging get will only fire when the LayoutInfo is different than the previously
    /// returned LayoutInfo. Note that, since LayoutInfo is a table, only some fields may have
    /// changed.
    ///
    /// It is invalid to call `GetLayout` while a previous call is still pending. Doing so will
    /// cause both this channel and the Flatland channel that handed out ParentViewportWatcher to be
    /// closed.
    GetLayout { responder: ParentViewportWatcherGetLayoutResponder },
    /// A hanging get for receiving the status of the parent Viewport. This provides global
    /// connectivity information to the child.
    ///
    /// This hanging get will only fire when the ParentViewportStatus is different than the
    /// previously returned ParentViewportStatus.
    ///
    /// It is invalid to call `GetStatus` while a previous call is still pending. Doing so will
    /// cause both this channel and the Flatland channel that handed out ParentViewportWatcher to be
    /// closed.
    GetStatus { responder: ParentViewportWatcherGetStatusResponder },
}

impl ParentViewportWatcherRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_layout(self) -> Option<(ParentViewportWatcherGetLayoutResponder)> {
        if let ParentViewportWatcherRequest::GetLayout { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_status(self) -> Option<(ParentViewportWatcherGetStatusResponder)> {
        if let ParentViewportWatcherRequest::GetStatus { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ParentViewportWatcherRequest::GetLayout { .. } => "get_layout",
            ParentViewportWatcherRequest::GetStatus { .. } => "get_status",
        }
    }
}

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

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

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

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

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

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

impl ParentViewportWatcherControlHandle {}

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

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

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

    fn send_raw(&self, mut info: &LayoutInfo) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ParentViewportWatcherGetLayoutResponse>(
            (info,),
            self.tx_id,
            0x3cbe5d9638e032,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

    fn send_raw(&self, mut status: ParentViewportStatus) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ParentViewportWatcherGetStatusResponse>(
            (status,),
            self.tx_id,
            0x7caa022f050d9ea6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

impl fidl::endpoints::ProtocolMarker for ScreenCaptureMarker {
    type Proxy = ScreenCaptureProxy;
    type RequestStream = ScreenCaptureRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ScreenCaptureSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.ui.composition.ScreenCapture";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ScreenCaptureMarker {}
pub type ScreenCaptureConfigureResult = Result<(), ScreenCaptureError>;
pub type ScreenCaptureGetNextFrameResult = Result<FrameInfo, ScreenCaptureError>;
pub type ScreenCaptureReleaseFrameResult = Result<(), ScreenCaptureError>;

pub trait ScreenCaptureProxyInterface: Send + Sync {
    type ConfigureResponseFut: std::future::Future<Output = Result<ScreenCaptureConfigureResult, fidl::Error>>
        + Send;
    fn r#configure(&self, payload: ScreenCaptureConfig) -> Self::ConfigureResponseFut;
    type GetNextFrameResponseFut: std::future::Future<Output = Result<ScreenCaptureGetNextFrameResult, fidl::Error>>
        + Send;
    fn r#get_next_frame(&self, payload: GetNextFrameArgs) -> Self::GetNextFrameResponseFut;
    type ReleaseFrameResponseFut: std::future::Future<Output = Result<ScreenCaptureReleaseFrameResult, fidl::Error>>
        + Send;
    fn r#release_frame(&self, buffer_id: u32) -> Self::ReleaseFrameResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ScreenCaptureSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ScreenCaptureSynchronousProxy {
    type Proxy = ScreenCaptureProxy;
    type Protocol = ScreenCaptureMarker;

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

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

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

    /// Clients should first use the Allocator protocol to register a
    /// BufferCollection. This function will fail with BAD_OPERATION unless all clients of the
    /// BufferCollection have set their constraints.
    ///
    /// Afterwards, clients should create and configure the images that will
    /// eventually be rendered to using this method. All the buffers in the
    /// collection from 0 to (buffer_count-1) may be used for screen capture.
    ///
    /// Clients are responsible for determining the rotation of the display,
    /// and applying the corrective rotation. For instance, if the display is
    /// mounted 90 degrees clockwise (the "top" is on the right, when looking
    /// at the display), then the client should specify a 270 degree rotation
    /// to account for it.
    ///
    /// Similarly, the clients are responsible for specifying a buffer big
    /// enough for the rotated image. If the buffer is too small, a best effort
    /// attempt will be made to render the image.
    ///
    /// Finally, clients request the server to render the current screen to the
    /// shared buffers using [`GetNextFrame`].
    ///
    /// [`Configure`] can be called again with a new BufferCollectionImportToken
    /// if the client wishes to change any of the configuration settings. In
    /// this case all the buffers from the previous call to [`Configure`] will
    /// be released.
    pub fn r#configure(
        &self,
        mut payload: ScreenCaptureConfig,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ScreenCaptureConfigureResult, fidl::Error> {
        let _response = self.client.send_query::<ScreenCaptureConfig, fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            ScreenCaptureError,
        >, ScreenCaptureMarker>(
            &mut payload,
            0x3b6e5af1d294afd9,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Following a successful call to [`Configure`], clients can call
    /// GetNextFrame. This will populate a buffer with the most recent frame.
    ///
    /// Clients should wait on the zx::event they pass for successful
    /// completion of the screenshot. It is not guaranteed that the screenshot
    /// will be completed by the time this function returns.
    ///
    /// The requested image will be in the BufferCollection that the client set
    /// up in the VMO at the index specified by buffer_id.
    ///
    /// When ScreenCapture is used to provide a stream, the rate that the
    /// client calls GetNextFrame will drive the frame rate.
    ///
    /// Errors:
    /// BAD_OPERATION if Configure was not called, or not called successfully
    /// MISSING_ARGS if a required argument is not present
    /// BUFFER_FULL if all buffers in the BufferCollection are in use. In this case, ReleaseFrame
    /// must be called to make a buffer available before this function can be called successfully.
    pub fn r#get_next_frame(
        &self,
        mut payload: GetNextFrameArgs,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ScreenCaptureGetNextFrameResult, fidl::Error> {
        let _response = self.client.send_query::<
            GetNextFrameArgs,
            fidl::encoding::ResultType<FrameInfo, ScreenCaptureError>,
            ScreenCaptureMarker,
        >(
            &mut payload,
            0x552c1580aab8c4a7,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Once the client no longer needs an image, they can call ReleaseFrame on
    /// the VMO index of the buffer so that the server can reuse it in the future.
    pub fn r#release_frame(
        &self,
        mut buffer_id: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ScreenCaptureReleaseFrameResult, fidl::Error> {
        let _response =
            self.client.send_query::<ScreenCaptureReleaseFrameRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                ScreenCaptureError,
            >, ScreenCaptureMarker>(
                (buffer_id,),
                0x46704dce24e35950,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ScreenCaptureProxy {
    type Protocol = ScreenCaptureMarker;

    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 ScreenCaptureProxy {
    /// Create a new Proxy for fuchsia.ui.composition/ScreenCapture.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ScreenCaptureMarker 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) -> ScreenCaptureEventStream {
        ScreenCaptureEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Clients should first use the Allocator protocol to register a
    /// BufferCollection. This function will fail with BAD_OPERATION unless all clients of the
    /// BufferCollection have set their constraints.
    ///
    /// Afterwards, clients should create and configure the images that will
    /// eventually be rendered to using this method. All the buffers in the
    /// collection from 0 to (buffer_count-1) may be used for screen capture.
    ///
    /// Clients are responsible for determining the rotation of the display,
    /// and applying the corrective rotation. For instance, if the display is
    /// mounted 90 degrees clockwise (the "top" is on the right, when looking
    /// at the display), then the client should specify a 270 degree rotation
    /// to account for it.
    ///
    /// Similarly, the clients are responsible for specifying a buffer big
    /// enough for the rotated image. If the buffer is too small, a best effort
    /// attempt will be made to render the image.
    ///
    /// Finally, clients request the server to render the current screen to the
    /// shared buffers using [`GetNextFrame`].
    ///
    /// [`Configure`] can be called again with a new BufferCollectionImportToken
    /// if the client wishes to change any of the configuration settings. In
    /// this case all the buffers from the previous call to [`Configure`] will
    /// be released.
    pub fn r#configure(
        &self,
        mut payload: ScreenCaptureConfig,
    ) -> fidl::client::QueryResponseFut<
        ScreenCaptureConfigureResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ScreenCaptureProxyInterface::r#configure(self, payload)
    }

    /// Following a successful call to [`Configure`], clients can call
    /// GetNextFrame. This will populate a buffer with the most recent frame.
    ///
    /// Clients should wait on the zx::event they pass for successful
    /// completion of the screenshot. It is not guaranteed that the screenshot
    /// will be completed by the time this function returns.
    ///
    /// The requested image will be in the BufferCollection that the client set
    /// up in the VMO at the index specified by buffer_id.
    ///
    /// When ScreenCapture is used to provide a stream, the rate that the
    /// client calls GetNextFrame will drive the frame rate.
    ///
    /// Errors:
    /// BAD_OPERATION if Configure was not called, or not called successfully
    /// MISSING_ARGS if a required argument is not present
    /// BUFFER_FULL if all buffers in the BufferCollection are in use. In this case, ReleaseFrame
    /// must be called to make a buffer available before this function can be called successfully.
    pub fn r#get_next_frame(
        &self,
        mut payload: GetNextFrameArgs,
    ) -> fidl::client::QueryResponseFut<
        ScreenCaptureGetNextFrameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ScreenCaptureProxyInterface::r#get_next_frame(self, payload)
    }

    /// Once the client no longer needs an image, they can call ReleaseFrame on
    /// the VMO index of the buffer so that the server can reuse it in the future.
    pub fn r#release_frame(
        &self,
        mut buffer_id: u32,
    ) -> fidl::client::QueryResponseFut<
        ScreenCaptureReleaseFrameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ScreenCaptureProxyInterface::r#release_frame(self, buffer_id)
    }
}

impl ScreenCaptureProxyInterface for ScreenCaptureProxy {
    type ConfigureResponseFut = fidl::client::QueryResponseFut<
        ScreenCaptureConfigureResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#configure(&self, mut payload: ScreenCaptureConfig) -> Self::ConfigureResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ScreenCaptureConfigureResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, ScreenCaptureError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3b6e5af1d294afd9,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<ScreenCaptureConfig, ScreenCaptureConfigureResult>(
            &mut payload,
            0x3b6e5af1d294afd9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetNextFrameResponseFut = fidl::client::QueryResponseFut<
        ScreenCaptureGetNextFrameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_next_frame(&self, mut payload: GetNextFrameArgs) -> Self::GetNextFrameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ScreenCaptureGetNextFrameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<FrameInfo, ScreenCaptureError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x552c1580aab8c4a7,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<GetNextFrameArgs, ScreenCaptureGetNextFrameResult>(
            &mut payload,
            0x552c1580aab8c4a7,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ReleaseFrameResponseFut = fidl::client::QueryResponseFut<
        ScreenCaptureReleaseFrameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#release_frame(&self, mut buffer_id: u32) -> Self::ReleaseFrameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ScreenCaptureReleaseFrameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, ScreenCaptureError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x46704dce24e35950,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ScreenCaptureReleaseFrameRequest,
            ScreenCaptureReleaseFrameResult,
        >(
            (buffer_id,),
            0x46704dce24e35950,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ScreenCaptureRequestStream {
    type Protocol = ScreenCaptureMarker;
    type ControlHandle = ScreenCaptureControlHandle;

    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 {
        ScreenCaptureControlHandle { 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 ScreenCaptureRequestStream {
    type Item = Result<ScreenCaptureRequest, 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 ScreenCaptureRequestStream 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 {
                    0x3b6e5af1d294afd9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ScreenCaptureConfig,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ScreenCaptureConfig>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ScreenCaptureControlHandle { inner: this.inner.clone() };
                        Ok(ScreenCaptureRequest::Configure {
                            payload: req,
                            responder: ScreenCaptureConfigureResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x552c1580aab8c4a7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            GetNextFrameArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<GetNextFrameArgs>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ScreenCaptureControlHandle { inner: this.inner.clone() };
                        Ok(ScreenCaptureRequest::GetNextFrame {
                            payload: req,
                            responder: ScreenCaptureGetNextFrameResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x46704dce24e35950 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ScreenCaptureReleaseFrameRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ScreenCaptureReleaseFrameRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ScreenCaptureControlHandle { inner: this.inner.clone() };
                        Ok(ScreenCaptureRequest::ReleaseFrame {
                            buffer_id: req.buffer_id,

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

/// This protocol provides a low-level ScreenCapture API for clients to use.
/// ScreenCapture clients should familiarize themselves with the
/// [`fuchsia.sysmem/BufferCollection`] and [`fuchsia.ui.composition/Allocator`] protocols
/// as those are necessary to create the BufferCollections and images ScreenCapture uses.
#[derive(Debug)]
pub enum ScreenCaptureRequest {
    /// Clients should first use the Allocator protocol to register a
    /// BufferCollection. This function will fail with BAD_OPERATION unless all clients of the
    /// BufferCollection have set their constraints.
    ///
    /// Afterwards, clients should create and configure the images that will
    /// eventually be rendered to using this method. All the buffers in the
    /// collection from 0 to (buffer_count-1) may be used for screen capture.
    ///
    /// Clients are responsible for determining the rotation of the display,
    /// and applying the corrective rotation. For instance, if the display is
    /// mounted 90 degrees clockwise (the "top" is on the right, when looking
    /// at the display), then the client should specify a 270 degree rotation
    /// to account for it.
    ///
    /// Similarly, the clients are responsible for specifying a buffer big
    /// enough for the rotated image. If the buffer is too small, a best effort
    /// attempt will be made to render the image.
    ///
    /// Finally, clients request the server to render the current screen to the
    /// shared buffers using [`GetNextFrame`].
    ///
    /// [`Configure`] can be called again with a new BufferCollectionImportToken
    /// if the client wishes to change any of the configuration settings. In
    /// this case all the buffers from the previous call to [`Configure`] will
    /// be released.
    Configure { payload: ScreenCaptureConfig, responder: ScreenCaptureConfigureResponder },
    /// Following a successful call to [`Configure`], clients can call
    /// GetNextFrame. This will populate a buffer with the most recent frame.
    ///
    /// Clients should wait on the zx::event they pass for successful
    /// completion of the screenshot. It is not guaranteed that the screenshot
    /// will be completed by the time this function returns.
    ///
    /// The requested image will be in the BufferCollection that the client set
    /// up in the VMO at the index specified by buffer_id.
    ///
    /// When ScreenCapture is used to provide a stream, the rate that the
    /// client calls GetNextFrame will drive the frame rate.
    ///
    /// Errors:
    /// BAD_OPERATION if Configure was not called, or not called successfully
    /// MISSING_ARGS if a required argument is not present
    /// BUFFER_FULL if all buffers in the BufferCollection are in use. In this case, ReleaseFrame
    /// must be called to make a buffer available before this function can be called successfully.
    GetNextFrame { payload: GetNextFrameArgs, responder: ScreenCaptureGetNextFrameResponder },
    /// Once the client no longer needs an image, they can call ReleaseFrame on
    /// the VMO index of the buffer so that the server can reuse it in the future.
    ReleaseFrame { buffer_id: u32, responder: ScreenCaptureReleaseFrameResponder },
}

impl ScreenCaptureRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_configure(self) -> Option<(ScreenCaptureConfig, ScreenCaptureConfigureResponder)> {
        if let ScreenCaptureRequest::Configure { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_next_frame(
        self,
    ) -> Option<(GetNextFrameArgs, ScreenCaptureGetNextFrameResponder)> {
        if let ScreenCaptureRequest::GetNextFrame { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_release_frame(self) -> Option<(u32, ScreenCaptureReleaseFrameResponder)> {
        if let ScreenCaptureRequest::ReleaseFrame { buffer_id, responder } = self {
            Some((buffer_id, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ScreenCaptureRequest::Configure { .. } => "configure",
            ScreenCaptureRequest::GetNextFrame { .. } => "get_next_frame",
            ScreenCaptureRequest::ReleaseFrame { .. } => "release_frame",
        }
    }
}

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

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

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

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

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

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

impl ScreenCaptureControlHandle {}

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

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

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

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

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

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

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

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

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

    fn send_raw(
        &self,
        mut result: Result<FrameInfo, ScreenCaptureError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<FrameInfo, ScreenCaptureError>>(
            result.as_mut().map_err(|e| *e),
            self.tx_id,
            0x552c1580aab8c4a7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for ScreenshotMarker {
    type Proxy = ScreenshotProxy;
    type RequestStream = ScreenshotRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ScreenshotSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.ui.composition.Screenshot";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ScreenshotMarker {}

pub trait ScreenshotProxyInterface: Send + Sync {
    type TakeResponseFut: std::future::Future<Output = Result<ScreenshotTakeResponse, fidl::Error>>
        + Send;
    fn r#take(&self, payload: ScreenshotTakeRequest) -> Self::TakeResponseFut;
    type TakeFileResponseFut: std::future::Future<Output = Result<ScreenshotTakeFileResponse, fidl::Error>>
        + Send;
    fn r#take_file(&self, payload: ScreenshotTakeFileRequest) -> Self::TakeFileResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ScreenshotSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ScreenshotSynchronousProxy {
    type Proxy = ScreenshotProxy;
    type Protocol = ScreenshotMarker;

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

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

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

    /// Collects the current graphical content of a display in a specified buffer `format` in the
    /// sRGB color space. Note that the sRGB color space is non-linear, meaning that unit tests
    /// doing pixel equality checks making use of non-fully saturated colors should convert to a
    /// linear color space.
    ///
    /// See https://fuchsia.dev/fuchsia-src/concepts/ui/scenic/color_spaces for more information.
    ///
    /// Screenshot is taken immediately, populated with the display's content from the most recent
    /// VSYNC.
    ///
    /// If the client calls [`Take`] a second time before a first [`Take`] call returns, the server
    /// will close the Screenshot connection with a ZX_ERR_SHOULD_WAIT epitaph.
    ///
    /// If capture fails due to an internal error, the server will close the Screenshot connection
    /// with a ZX_ERR_INTERNAL epitaph.
    pub fn r#take(
        &self,
        mut payload: ScreenshotTakeRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ScreenshotTakeResponse, fidl::Error> {
        let _response = self
            .client
            .send_query::<ScreenshotTakeRequest, ScreenshotTakeResponse, ScreenshotMarker>(
                &mut payload,
                0x51341396e9fd2fd0,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Collects the current graphical content of a display in a specified buffer `format` in the
    /// sRGB color space. Note that the sRGB color space is non-linear, meaning that unit tests
    /// doing pixel equality checks making use of non-fully saturated colors should convert to a
    /// linear color space.
    ///
    /// TODO(https://fxbug.dev/42065844): Link to fuchsia.dev documentation when it's up.
    ///
    /// Screenshot is taken immediately, populated with the display's content from the most recent
    /// VSYNC.
    ///
    /// If the client calls [`TakeFile`] a second time before a first [`TakeFile`] call returns,
    /// the server will close the Screenshot connection with a ZX_ERR_SHOULD_WAIT epitaph.
    ///
    /// If capture fails due to an internal error, the server will close the Screenshot connection
    /// with a ZX_ERR_INTERNAL epitaph.
    ///
    /// This call should be used if the client is on the host and does not support VMOs,
    /// as is the case for ffx tools.
    pub fn r#take_file(
        &self,
        mut payload: ScreenshotTakeFileRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ScreenshotTakeFileResponse, fidl::Error> {
        let _response = self
            .client
            .send_query::<ScreenshotTakeFileRequest, ScreenshotTakeFileResponse, ScreenshotMarker>(
                &mut payload,
                0x470aeea0a4d32903,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for ScreenshotProxy {
    type Protocol = ScreenshotMarker;

    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 ScreenshotProxy {
    /// Create a new Proxy for fuchsia.ui.composition/Screenshot.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ScreenshotMarker 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) -> ScreenshotEventStream {
        ScreenshotEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Collects the current graphical content of a display in a specified buffer `format` in the
    /// sRGB color space. Note that the sRGB color space is non-linear, meaning that unit tests
    /// doing pixel equality checks making use of non-fully saturated colors should convert to a
    /// linear color space.
    ///
    /// See https://fuchsia.dev/fuchsia-src/concepts/ui/scenic/color_spaces for more information.
    ///
    /// Screenshot is taken immediately, populated with the display's content from the most recent
    /// VSYNC.
    ///
    /// If the client calls [`Take`] a second time before a first [`Take`] call returns, the server
    /// will close the Screenshot connection with a ZX_ERR_SHOULD_WAIT epitaph.
    ///
    /// If capture fails due to an internal error, the server will close the Screenshot connection
    /// with a ZX_ERR_INTERNAL epitaph.
    pub fn r#take(
        &self,
        mut payload: ScreenshotTakeRequest,
    ) -> fidl::client::QueryResponseFut<
        ScreenshotTakeResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ScreenshotProxyInterface::r#take(self, payload)
    }

    /// Collects the current graphical content of a display in a specified buffer `format` in the
    /// sRGB color space. Note that the sRGB color space is non-linear, meaning that unit tests
    /// doing pixel equality checks making use of non-fully saturated colors should convert to a
    /// linear color space.
    ///
    /// TODO(https://fxbug.dev/42065844): Link to fuchsia.dev documentation when it's up.
    ///
    /// Screenshot is taken immediately, populated with the display's content from the most recent
    /// VSYNC.
    ///
    /// If the client calls [`TakeFile`] a second time before a first [`TakeFile`] call returns,
    /// the server will close the Screenshot connection with a ZX_ERR_SHOULD_WAIT epitaph.
    ///
    /// If capture fails due to an internal error, the server will close the Screenshot connection
    /// with a ZX_ERR_INTERNAL epitaph.
    ///
    /// This call should be used if the client is on the host and does not support VMOs,
    /// as is the case for ffx tools.
    pub fn r#take_file(
        &self,
        mut payload: ScreenshotTakeFileRequest,
    ) -> fidl::client::QueryResponseFut<
        ScreenshotTakeFileResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ScreenshotProxyInterface::r#take_file(self, payload)
    }
}

impl ScreenshotProxyInterface for ScreenshotProxy {
    type TakeResponseFut = fidl::client::QueryResponseFut<
        ScreenshotTakeResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#take(&self, mut payload: ScreenshotTakeRequest) -> Self::TakeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ScreenshotTakeResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ScreenshotTakeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x51341396e9fd2fd0,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<ScreenshotTakeRequest, ScreenshotTakeResponse>(
            &mut payload,
            0x51341396e9fd2fd0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

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

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for ScreenshotRequestStream {
    type Protocol = ScreenshotMarker;
    type ControlHandle = ScreenshotControlHandle;

    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 {
        ScreenshotControlHandle { 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 ScreenshotRequestStream {
    type Item = Result<ScreenshotRequest, 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 ScreenshotRequestStream 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 {
                    0x51341396e9fd2fd0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ScreenshotTakeRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ScreenshotTakeRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ScreenshotControlHandle { inner: this.inner.clone() };
                        Ok(ScreenshotRequest::Take {
                            payload: req,
                            responder: ScreenshotTakeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x470aeea0a4d32903 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ScreenshotTakeFileRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ScreenshotTakeFileRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ScreenshotControlHandle { inner: this.inner.clone() };
                        Ok(ScreenshotRequest::TakeFile {
                            payload: req,
                            responder: ScreenshotTakeFileResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ScreenshotMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Collects the current graphical content of a display.
#[derive(Debug)]
pub enum ScreenshotRequest {
    /// Collects the current graphical content of a display in a specified buffer `format` in the
    /// sRGB color space. Note that the sRGB color space is non-linear, meaning that unit tests
    /// doing pixel equality checks making use of non-fully saturated colors should convert to a
    /// linear color space.
    ///
    /// See https://fuchsia.dev/fuchsia-src/concepts/ui/scenic/color_spaces for more information.
    ///
    /// Screenshot is taken immediately, populated with the display's content from the most recent
    /// VSYNC.
    ///
    /// If the client calls [`Take`] a second time before a first [`Take`] call returns, the server
    /// will close the Screenshot connection with a ZX_ERR_SHOULD_WAIT epitaph.
    ///
    /// If capture fails due to an internal error, the server will close the Screenshot connection
    /// with a ZX_ERR_INTERNAL epitaph.
    Take { payload: ScreenshotTakeRequest, responder: ScreenshotTakeResponder },
    /// Collects the current graphical content of a display in a specified buffer `format` in the
    /// sRGB color space. Note that the sRGB color space is non-linear, meaning that unit tests
    /// doing pixel equality checks making use of non-fully saturated colors should convert to a
    /// linear color space.
    ///
    /// TODO(https://fxbug.dev/42065844): Link to fuchsia.dev documentation when it's up.
    ///
    /// Screenshot is taken immediately, populated with the display's content from the most recent
    /// VSYNC.
    ///
    /// If the client calls [`TakeFile`] a second time before a first [`TakeFile`] call returns,
    /// the server will close the Screenshot connection with a ZX_ERR_SHOULD_WAIT epitaph.
    ///
    /// If capture fails due to an internal error, the server will close the Screenshot connection
    /// with a ZX_ERR_INTERNAL epitaph.
    ///
    /// This call should be used if the client is on the host and does not support VMOs,
    /// as is the case for ffx tools.
    TakeFile { payload: ScreenshotTakeFileRequest, responder: ScreenshotTakeFileResponder },
}

impl ScreenshotRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_take(self) -> Option<(ScreenshotTakeRequest, ScreenshotTakeResponder)> {
        if let ScreenshotRequest::Take { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_take_file(
        self,
    ) -> Option<(ScreenshotTakeFileRequest, ScreenshotTakeFileResponder)> {
        if let ScreenshotRequest::TakeFile { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ScreenshotRequest::Take { .. } => "take",
            ScreenshotRequest::TakeFile { .. } => "take_file",
        }
    }
}

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

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

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

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

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

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

impl ScreenshotControlHandle {}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::ProtocolMarker for TrustedFlatlandMarker {
    type Proxy = TrustedFlatlandProxy;
    type RequestStream = TrustedFlatlandRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = TrustedFlatlandSynchronousProxy;

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

pub trait TrustedFlatlandProxyInterface: Send + Sync {
    fn r#release_image_immediately(&self, image_id: &ContentId) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct TrustedFlatlandSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for TrustedFlatlandSynchronousProxy {
    type Proxy = TrustedFlatlandProxy;
    type Protocol = TrustedFlatlandMarker;

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

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

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

    /// Releases an image immediately, without waiting for the next present.
    pub fn r#release_image_immediately(&self, mut image_id: &ContentId) -> Result<(), fidl::Error> {
        self.client.send::<TrustedFlatlandReleaseImageImmediatelyRequest>(
            (image_id,),
            0x245e1ac080772c8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for TrustedFlatlandProxy {
    type Protocol = TrustedFlatlandMarker;

    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 TrustedFlatlandProxy {
    /// Create a new Proxy for fuchsia.ui.composition/TrustedFlatland.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <TrustedFlatlandMarker 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) -> TrustedFlatlandEventStream {
        TrustedFlatlandEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Releases an image immediately, without waiting for the next present.
    pub fn r#release_image_immediately(&self, mut image_id: &ContentId) -> Result<(), fidl::Error> {
        TrustedFlatlandProxyInterface::r#release_image_immediately(self, image_id)
    }
}

impl TrustedFlatlandProxyInterface for TrustedFlatlandProxy {
    fn r#release_image_immediately(&self, mut image_id: &ContentId) -> Result<(), fidl::Error> {
        self.client.send::<TrustedFlatlandReleaseImageImmediatelyRequest>(
            (image_id,),
            0x245e1ac080772c8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for TrustedFlatlandRequestStream {
    type Protocol = TrustedFlatlandMarker;
    type ControlHandle = TrustedFlatlandControlHandle;

    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 {
        TrustedFlatlandControlHandle { 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 TrustedFlatlandRequestStream {
    type Item = Result<TrustedFlatlandRequest, 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 TrustedFlatlandRequestStream 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 {
                    0x245e1ac080772c8 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            TrustedFlatlandReleaseImageImmediatelyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TrustedFlatlandReleaseImageImmediatelyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            TrustedFlatlandControlHandle { inner: this.inner.clone() };
                        Ok(TrustedFlatlandRequest::ReleaseImageImmediately {
                            image_id: req.image_id,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <TrustedFlatlandMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A privileged protocol for trusted Flatland sessions that require special capabilities.
///
/// This protocol is composed into the [Flatland] protocol. Methods in this protocol
/// are only available if the Flatland session was created via [TrustedFlatlandFactory].
#[derive(Debug)]
pub enum TrustedFlatlandRequest {
    /// Releases an image immediately, without waiting for the next present.
    ReleaseImageImmediately { image_id: ContentId, control_handle: TrustedFlatlandControlHandle },
}

impl TrustedFlatlandRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_release_image_immediately(
        self,
    ) -> Option<(ContentId, TrustedFlatlandControlHandle)> {
        if let TrustedFlatlandRequest::ReleaseImageImmediately { image_id, control_handle } = self {
            Some((image_id, control_handle))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

impl TrustedFlatlandControlHandle {}

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

impl fidl::endpoints::ProtocolMarker for TrustedFlatlandFactoryMarker {
    type Proxy = TrustedFlatlandFactoryProxy;
    type RequestStream = TrustedFlatlandFactoryRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = TrustedFlatlandFactorySynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.ui.composition.TrustedFlatlandFactory";
}
impl fidl::endpoints::DiscoverableProtocolMarker for TrustedFlatlandFactoryMarker {}
pub type TrustedFlatlandFactoryCreateFlatlandResult = Result<(), TrustedFlatlandFactoryError>;

pub trait TrustedFlatlandFactoryProxyInterface: Send + Sync {
    type CreateFlatlandResponseFut: std::future::Future<
            Output = Result<TrustedFlatlandFactoryCreateFlatlandResult, fidl::Error>,
        > + Send;
    fn r#create_flatland(
        &self,
        server_end: fidl::endpoints::ServerEnd<FlatlandMarker>,
        config: TrustedFlatlandConfig,
    ) -> Self::CreateFlatlandResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct TrustedFlatlandFactorySynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for TrustedFlatlandFactorySynchronousProxy {
    type Proxy = TrustedFlatlandFactoryProxy;
    type Protocol = TrustedFlatlandFactoryMarker;

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

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

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

    /// Creates a new Flatland session with the specified configuration.
    ///
    /// ## Error
    ///
    /// Returns a [TrustedFlatlandFactoryError] error if the operation fails.
    pub fn r#create_flatland(
        &self,
        mut server_end: fidl::endpoints::ServerEnd<FlatlandMarker>,
        mut config: TrustedFlatlandConfig,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<TrustedFlatlandFactoryCreateFlatlandResult, fidl::Error> {
        let _response = self.client.send_query::<
            TrustedFlatlandFactoryCreateFlatlandRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, TrustedFlatlandFactoryError>,
            TrustedFlatlandFactoryMarker,
        >(
            (server_end, &mut config,),
            0x48e89c53f00561dc,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }
}

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

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

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

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

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

impl fidl::endpoints::Proxy for TrustedFlatlandFactoryProxy {
    type Protocol = TrustedFlatlandFactoryMarker;

    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 TrustedFlatlandFactoryProxy {
    /// Create a new Proxy for fuchsia.ui.composition/TrustedFlatlandFactory.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <TrustedFlatlandFactoryMarker 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) -> TrustedFlatlandFactoryEventStream {
        TrustedFlatlandFactoryEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates a new Flatland session with the specified configuration.
    ///
    /// ## Error
    ///
    /// Returns a [TrustedFlatlandFactoryError] error if the operation fails.
    pub fn r#create_flatland(
        &self,
        mut server_end: fidl::endpoints::ServerEnd<FlatlandMarker>,
        mut config: TrustedFlatlandConfig,
    ) -> fidl::client::QueryResponseFut<
        TrustedFlatlandFactoryCreateFlatlandResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        TrustedFlatlandFactoryProxyInterface::r#create_flatland(self, server_end, config)
    }
}

impl TrustedFlatlandFactoryProxyInterface for TrustedFlatlandFactoryProxy {
    type CreateFlatlandResponseFut = fidl::client::QueryResponseFut<
        TrustedFlatlandFactoryCreateFlatlandResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#create_flatland(
        &self,
        mut server_end: fidl::endpoints::ServerEnd<FlatlandMarker>,
        mut config: TrustedFlatlandConfig,
    ) -> Self::CreateFlatlandResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<TrustedFlatlandFactoryCreateFlatlandResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    TrustedFlatlandFactoryError,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x48e89c53f00561dc,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            TrustedFlatlandFactoryCreateFlatlandRequest,
            TrustedFlatlandFactoryCreateFlatlandResult,
        >(
            (server_end, &mut config,),
            0x48e89c53f00561dc,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

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

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

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

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

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

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

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

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

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

impl fidl::endpoints::RequestStream for TrustedFlatlandFactoryRequestStream {
    type Protocol = TrustedFlatlandFactoryMarker;
    type ControlHandle = TrustedFlatlandFactoryControlHandle;

    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 {
        TrustedFlatlandFactoryControlHandle { 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 TrustedFlatlandFactoryRequestStream {
    type Item = Result<TrustedFlatlandFactoryRequest, 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 TrustedFlatlandFactoryRequestStream 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 {
                0x48e89c53f00561dc => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(TrustedFlatlandFactoryCreateFlatlandRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TrustedFlatlandFactoryCreateFlatlandRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = TrustedFlatlandFactoryControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(TrustedFlatlandFactoryRequest::CreateFlatland {server_end: req.server_end,
config: req.config,

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

/// A privileged factory for creating Flatland sessions with special configurations.
///
/// This protocol is intended for trusted clients that require fine-grained control over
/// Flatland's behavior for performance-critical applications. It is not intended for
/// general use. Misuse of this API can negatively impact system performance and stability.
#[derive(Debug)]
pub enum TrustedFlatlandFactoryRequest {
    /// Creates a new Flatland session with the specified configuration.
    ///
    /// ## Error
    ///
    /// Returns a [TrustedFlatlandFactoryError] error if the operation fails.
    CreateFlatland {
        server_end: fidl::endpoints::ServerEnd<FlatlandMarker>,
        config: TrustedFlatlandConfig,
        responder: TrustedFlatlandFactoryCreateFlatlandResponder,
    },
}

impl TrustedFlatlandFactoryRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_flatland(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<FlatlandMarker>,
        TrustedFlatlandConfig,
        TrustedFlatlandFactoryCreateFlatlandResponder,
    )> {
        if let TrustedFlatlandFactoryRequest::CreateFlatland { server_end, config, responder } =
            self
        {
            Some((server_end, config, responder))
        } else {
            None
        }
    }

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

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

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

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

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

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

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

impl TrustedFlatlandFactoryControlHandle {}

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

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

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

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

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

mod internal {
    use super::*;

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

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for BufferCollectionExportToken
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                value: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for BufferCollectionImportToken
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                value: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ChildViewWatcherGetViewRefResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                view_ref: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewRef,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

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

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

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            FlatlandCreateImageRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FlatlandCreateImageRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandCreateImageRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandCreateImageRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <ContentId as fidl::encoding::ValueTypeMarker>::borrow(&self.image_id),
                    <BufferCollectionImportToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.import_token),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.vmo_index),
                    <ImageProperties as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<ContentId, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                BufferCollectionImportToken,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T3: fidl::encoding::Encode<ImageProperties, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<
            FlatlandCreateImageRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandCreateImageRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 12, depth)?;
            self.3.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FlatlandCreateImageRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                image_id: fidl::new_empty!(
                    ContentId,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                import_token: fidl::new_empty!(
                    BufferCollectionImportToken,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                vmo_index: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                properties: fidl::new_empty!(
                    ImageProperties,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                ContentId,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.image_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                BufferCollectionImportToken,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.import_token,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.vmo_index,
                decoder,
                offset + 12,
                _depth
            )?;
            fidl::decode!(
                ImageProperties,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.properties,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            FlatlandCreateView2Request,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FlatlandCreateView2Request
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandCreateView2Request>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandCreateView2Request, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.token),
                    <fidl_fuchsia_ui_views::ViewIdentityOnCreation as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.view_identity),
                    <ViewBoundProtocols as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.protocols),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.parent_viewport_watcher),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl_fuchsia_ui_views::ViewCreationToken,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl_fuchsia_ui_views::ViewIdentityOnCreation,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<ViewBoundProtocols, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T3: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            FlatlandCreateView2Request,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandCreateView2Request>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 16, depth)?;
            self.3.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FlatlandCreateView2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                token: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewCreationToken,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                view_identity: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewIdentityOnCreation,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                protocols: fidl::new_empty!(
                    ViewBoundProtocols,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                parent_viewport_watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl_fuchsia_ui_views::ViewCreationToken,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.token,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_ui_views::ViewIdentityOnCreation,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.view_identity,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                ViewBoundProtocols,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.protocols,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.parent_viewport_watcher,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            FlatlandCreateViewRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FlatlandCreateViewRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandCreateViewRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandCreateViewRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.token),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.parent_viewport_watcher),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl_fuchsia_ui_views::ViewCreationToken,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            FlatlandCreateViewRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandCreateViewRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FlatlandCreateViewRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                token: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewCreationToken,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                parent_viewport_watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<ParentViewportWatcherMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            FlatlandCreateViewportRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FlatlandCreateViewportRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandCreateViewportRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandCreateViewportRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <ContentId as fidl::encoding::ValueTypeMarker>::borrow(&self.viewport_id),
                    <fidl_fuchsia_ui_views::ViewportCreationToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.token),
                    <ViewportProperties as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ChildViewWatcherMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.child_view_watcher),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<ContentId, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl_fuchsia_ui_views::ViewportCreationToken,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<ViewportProperties, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T3: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ChildViewWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            FlatlandCreateViewportRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandCreateViewportRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 16, depth)?;
            self.3.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FlatlandCreateViewportRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                viewport_id: fidl::new_empty!(
                    ContentId,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                token: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewportCreationToken,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                properties: fidl::new_empty!(
                    ViewportProperties,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                child_view_watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ChildViewWatcherMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                ContentId,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.viewport_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_ui_views::ViewportCreationToken,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.token,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                ViewportProperties,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.properties,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ChildViewWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.child_view_watcher,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            FlatlandDisplaySetContentRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FlatlandDisplaySetContentRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandDisplaySetContentRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandDisplaySetContentRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_ui_views::ViewportCreationToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.token),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ChildViewWatcherMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.child_view_watcher),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl_fuchsia_ui_views::ViewportCreationToken,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ChildViewWatcherMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            FlatlandDisplaySetContentRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandDisplaySetContentRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FlatlandDisplaySetContentRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                token: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewportCreationToken,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                child_view_watcher: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ChildViewWatcherMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FlatlandReleaseViewportResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                token: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewportCreationToken,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            FlatlandSetSolidFillRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FlatlandSetSolidFillRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetSolidFillRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FlatlandSetSolidFillRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <ContentId as fidl::encoding::ValueTypeMarker>::borrow(&self.rect_id),
                    <ColorRgba as fidl::encoding::ValueTypeMarker>::borrow(&self.color),
                    <fidl_fuchsia_math::SizeU as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.size,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<ContentId, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<ColorRgba, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl_fuchsia_math::SizeU,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            FlatlandSetSolidFillRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetSolidFillRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FlatlandSetSolidFillRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                rect_id: fidl::new_empty!(ContentId, fidl::encoding::DefaultFuchsiaResourceDialect),
                color: fidl::new_empty!(ColorRgba, fidl::encoding::DefaultFuchsiaResourceDialect),
                size: fidl::new_empty!(
                    fidl_fuchsia_math::SizeU,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                ContentId,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.rect_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                ColorRgba,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.color,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_math::SizeU,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.size,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TrustedFlatlandFactoryCreateFlatlandRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                server_end: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FlatlandMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                config: fidl::new_empty!(
                    TrustedFlatlandConfig,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

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

    impl fidl::encoding::ResourceTypeMarker for FrameInfo {
        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 FrameInfo {
        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<FrameInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut FrameInfo
    {
        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::<FrameInfo>(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::<
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.buffer_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for FrameInfo {
        #[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 =
                    <u32 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.buffer_id.get_or_insert_with(|| {
                    fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u32,
                    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 GetNextFrameArgs {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.event {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for GetNextFrameArgs {
        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 GetNextFrameArgs {
        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<GetNextFrameArgs, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut GetNextFrameArgs
    {
        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::<GetNextFrameArgs>(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::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.event.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    > 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 GetNextFrameArgs
    {
        #[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::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.event.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // 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 PresentArgs {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.release_counters {
                return 8;
            }
            if let Some(_) = self.present_fences {
                return 7;
            }
            if let Some(_) = self.unsquashable {
                return 4;
            }
            if let Some(_) = self.release_fences {
                return 3;
            }
            if let Some(_) = self.acquire_fences {
                return 2;
            }
            if let Some(_) = self.requested_presentation_time {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PresentArgs {
        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 PresentArgs {
        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<PresentArgs, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut PresentArgs
    {
        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::<PresentArgs>(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::<
                i64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.requested_presentation_time
                    .as_ref()
                    .map(<i64 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::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                    16,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.acquire_fences.as_mut().map(
                    <fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            2147483648,
                        >,
                        16,
                    > 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::Vector<
                    fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                    16,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.release_fences.as_mut().map(
                    <fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            2147483648,
                        >,
                        16,
                    > 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::<
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.unsquashable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::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::Vector<
                    fidl::encoding::HandleType<
                        fidl::Counter,
                        { fidl::ObjectType::COUNTER.into_raw() },
                        2147483648,
                    >,
                    16,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.present_fences.as_mut().map(
                    <fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Counter,
                            { fidl::ObjectType::COUNTER.into_raw() },
                            2147483648,
                        >,
                        16,
                    > 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::<
                fidl::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::Counter,
                        { fidl::ObjectType::COUNTER.into_raw() },
                        2147483648,
                    >,
                    16,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.release_counters.as_mut().map(
                    <fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Counter,
                            { fidl::ObjectType::COUNTER.into_raw() },
                            2147483648,
                        >,
                        16,
                    > 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 PresentArgs {
        #[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 =
                    <i64 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.requested_presentation_time.get_or_insert_with(|| {
                    fidl::new_empty!(i64, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    i64,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                    16,
                > 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.acquire_fences.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::Event,
                                { fidl::ObjectType::EVENT.into_raw() },
                                2147483648,
                            >,
                            16,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            2147483648,
                        >,
                        16,
                    >,
                    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::Vector<
                    fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                    16,
                > 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.release_fences.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::Event,
                                { fidl::ObjectType::EVENT.into_raw() },
                                2147483648,
                            >,
                            16,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            2147483648,
                        >,
                        16,
                    >,
                    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 =
                    <bool 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.unsquashable.get_or_insert_with(|| {
                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    bool,
                    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::Vector<
                    fidl::encoding::HandleType<
                        fidl::Counter,
                        { fidl::ObjectType::COUNTER.into_raw() },
                        2147483648,
                    >,
                    16,
                > 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.present_fences.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::Counter,
                                { fidl::ObjectType::COUNTER.into_raw() },
                                2147483648,
                            >,
                            16,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Counter,
                            { fidl::ObjectType::COUNTER.into_raw() },
                            2147483648,
                        >,
                        16,
                    >,
                    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 = <fidl::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::Counter,
                        { fidl::ObjectType::COUNTER.into_raw() },
                        2147483648,
                    >,
                    16,
                > 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.release_counters.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::Counter,
                                { fidl::ObjectType::COUNTER.into_raw() },
                                2147483648,
                            >,
                            16,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Counter,
                            { fidl::ObjectType::COUNTER.into_raw() },
                            2147483648,
                        >,
                        16,
                    >,
                    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 RegisterBufferCollectionArgs {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.buffer_collection_token2 {
                return 5;
            }
            if let Some(_) = self.usages {
                return 4;
            }
            if let Some(_) = self.usage {
                return 3;
            }
            if let Some(_) = self.buffer_collection_token {
                return 2;
            }
            if let Some(_) = self.export_token {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for RegisterBufferCollectionArgs {
        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 RegisterBufferCollectionArgs {
        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<
            RegisterBufferCollectionArgs,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut RegisterBufferCollectionArgs
    {
        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::<RegisterBufferCollectionArgs>(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::<BufferCollectionExportToken, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.export_token.as_mut().map(<BufferCollectionExportToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_sysmem::BufferCollectionTokenMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.buffer_collection_token.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<
                            fidl_fuchsia_sysmem::BufferCollectionTokenMarker,
                        >,
                    > 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::<
                RegisterBufferCollectionUsage,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.usage.as_ref().map(
                    <RegisterBufferCollectionUsage as fidl::encoding::ValueTypeMarker>::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::<
                RegisterBufferCollectionUsages,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.usages.as_ref().map(
                    <RegisterBufferCollectionUsages as fidl::encoding::ValueTypeMarker>::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_sysmem2::BufferCollectionTokenMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.buffer_collection_token2.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<
                            fidl_fuchsia_sysmem2::BufferCollectionTokenMarker,
                        >,
                    > 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 RegisterBufferCollectionArgs
    {
        #[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 =
                    <BufferCollectionExportToken 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.export_token.get_or_insert_with(|| {
                    fidl::new_empty!(
                        BufferCollectionExportToken,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    BufferCollectionExportToken,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_sysmem::BufferCollectionTokenMarker>,
                > 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.buffer_collection_token.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<
                                fidl_fuchsia_sysmem::BufferCollectionTokenMarker,
                            >,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<
                            fidl_fuchsia_sysmem::BufferCollectionTokenMarker,
                        >,
                    >,
                    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 =
                    <RegisterBufferCollectionUsage 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.usage.get_or_insert_with(|| {
                    fidl::new_empty!(
                        RegisterBufferCollectionUsage,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    RegisterBufferCollectionUsage,
                    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 =
                    <RegisterBufferCollectionUsages 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.usages.get_or_insert_with(|| {
                    fidl::new_empty!(
                        RegisterBufferCollectionUsages,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    RegisterBufferCollectionUsages,
                    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_sysmem2::BufferCollectionTokenMarker>,
                > 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.buffer_collection_token2.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<
                                fidl_fuchsia_sysmem2::BufferCollectionTokenMarker,
                            >,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<
                            fidl_fuchsia_sysmem2::BufferCollectionTokenMarker,
                        >,
                    >,
                    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 ScreenCaptureConfig {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.rotation {
                return 4;
            }
            if let Some(_) = self.buffer_count {
                return 3;
            }
            if let Some(_) = self.size {
                return 2;
            }
            if let Some(_) = self.import_token {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ScreenCaptureConfig {
        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 ScreenCaptureConfig {
        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<ScreenCaptureConfig, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut ScreenCaptureConfig
    {
        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::<ScreenCaptureConfig>(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::<BufferCollectionImportToken, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.import_token.as_mut().map(<BufferCollectionImportToken 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_math::SizeU,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.size
                    .as_ref()
                    .map(<fidl_fuchsia_math::SizeU as fidl::encoding::ValueTypeMarker>::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::<
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.buffer_count.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::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::<
                Rotation,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.rotation.as_ref().map(<Rotation as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ScreenCaptureConfig
    {
        #[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 =
                    <BufferCollectionImportToken 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.import_token.get_or_insert_with(|| {
                    fidl::new_empty!(
                        BufferCollectionImportToken,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    BufferCollectionImportToken,
                    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_math::SizeU 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.size.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl_fuchsia_math::SizeU,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_math::SizeU,
                    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 =
                    <u32 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.buffer_count.get_or_insert_with(|| {
                    fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u32,
                    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 =
                    <Rotation 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.rotation.get_or_insert_with(|| {
                    fidl::new_empty!(Rotation, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    Rotation,
                    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 ScreenshotTakeFileRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.format {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ScreenshotTakeFileRequest {
        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 ScreenshotTakeFileRequest {
        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<
            ScreenshotTakeFileRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ScreenshotTakeFileRequest
    {
        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::<ScreenshotTakeFileRequest>(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::<
                ScreenshotFormat,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.format
                    .as_ref()
                    .map(<ScreenshotFormat as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ScreenshotTakeFileRequest
    {
        #[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 =
                    <ScreenshotFormat 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.format.get_or_insert_with(|| {
                    fidl::new_empty!(
                        ScreenshotFormat,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    ScreenshotFormat,
                    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 ScreenshotTakeFileResponse {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.size {
                return 2;
            }
            if let Some(_) = self.file {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ScreenshotTakeFileResponse {
        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 ScreenshotTakeFileResponse {
        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<
            ScreenshotTakeFileResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ScreenshotTakeFileResponse
    {
        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::<ScreenshotTakeFileResponse>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.file.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
                    > 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_math::SizeU,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.size
                    .as_ref()
                    .map(<fidl_fuchsia_math::SizeU as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
                > 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.file.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::FileMarker>,
                    >,
                    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_math::SizeU 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.size.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl_fuchsia_math::SizeU,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_math::SizeU,
                    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 ScreenshotTakeRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.format {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ScreenshotTakeRequest {
        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 ScreenshotTakeRequest {
        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<ScreenshotTakeRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut ScreenshotTakeRequest
    {
        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::<ScreenshotTakeRequest>(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::<
                ScreenshotFormat,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.format
                    .as_ref()
                    .map(<ScreenshotFormat as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ScreenshotTakeRequest
    {
        #[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 =
                    <ScreenshotFormat 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.format.get_or_insert_with(|| {
                    fidl::new_empty!(
                        ScreenshotFormat,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    ScreenshotFormat,
                    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 ScreenshotTakeResponse {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.size {
                return 2;
            }
            if let Some(_) = self.vmo {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ScreenshotTakeResponse {
        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 ScreenshotTakeResponse {
        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<
            ScreenshotTakeResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ScreenshotTakeResponse
    {
        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::<ScreenshotTakeResponse>(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::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.vmo.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::Vmo,
                        { fidl::ObjectType::VMO.into_raw() },
                        2147483648,
                    > 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_math::SizeU,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.size
                    .as_ref()
                    .map(<fidl_fuchsia_math::SizeU as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ScreenshotTakeResponse
    {
        #[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::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.vmo.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 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_math::SizeU 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.size.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl_fuchsia_math::SizeU,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_math::SizeU,
                    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 TrustedFlatlandConfig {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.skips_on_frame_presented {
                return 4;
            }
            if let Some(_) = self.skips_present_credits {
                return 3;
            }
            if let Some(_) = self.pass_acquire_fences {
                return 2;
            }
            if let Some(_) = self.schedule_asap {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TrustedFlatlandConfig {
        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 TrustedFlatlandConfig {
        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<TrustedFlatlandConfig, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut TrustedFlatlandConfig
    {
        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::<TrustedFlatlandConfig>(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::<
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.schedule_asap.as_ref().map(<bool 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::<
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.pass_acquire_fences
                    .as_ref()
                    .map(<bool as fidl::encoding::ValueTypeMarker>::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::<
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.skips_present_credits
                    .as_ref()
                    .map(<bool as fidl::encoding::ValueTypeMarker>::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::<
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.skips_on_frame_presented
                    .as_ref()
                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TrustedFlatlandConfig
    {
        #[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 =
                    <bool 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.schedule_asap.get_or_insert_with(|| {
                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    bool,
                    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 =
                    <bool 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.pass_acquire_fences.get_or_insert_with(|| {
                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    bool,
                    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 =
                    <bool 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.skips_present_credits.get_or_insert_with(|| {
                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    bool,
                    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 =
                    <bool 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.skips_on_frame_presented.get_or_insert_with(|| {
                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    bool,
                    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 ViewBoundProtocols {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.mouse_source {
                return 4;
            }
            if let Some(_) = self.touch_source {
                return 3;
            }
            if let Some(_) = self.view_focuser {
                return 2;
            }
            if let Some(_) = self.view_ref_focused {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ViewBoundProtocols {
        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 ViewBoundProtocols {
        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<ViewBoundProtocols, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut ViewBoundProtocols
    {
        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::<ViewBoundProtocols>(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<fidl_fuchsia_ui_views::ViewRefFocusedMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.view_ref_focused.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::ViewRefFocusedMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::FocuserMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.view_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;
            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::ServerEnd<fidl_fuchsia_ui_pointer::TouchSourceMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.touch_source.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::TouchSourceMarker>,
                    > 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::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.mouse_source.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
                    > 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 ViewBoundProtocols
    {
        #[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<fidl_fuchsia_ui_views::ViewRefFocusedMarker>,
                > 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_focused.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::ViewRefFocusedMarker>,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::ViewRefFocusedMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::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.view_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;
            _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::ServerEnd<fidl_fuchsia_ui_pointer::TouchSourceMarker>,
                > 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_source.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::TouchSourceMarker>,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::TouchSourceMarker>,
                    >,
                    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::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
                > 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_source.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_ui_pointer::MouseSourceMarker>,
                    >,
                    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(())
        }
    }
}