fidl_fuchsia_ui_composition_common/

fidl_fuchsia_ui_composition_common.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::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

/// A user-defined identifier for future presentation info. A maximum of 8
/// future presentation counts is enough for the current usage of these APIs.
pub type FuturePresentationInfos = Vec<fidl_fuchsia_scenic_scheduling_common::PresentationInfo>;

pub const MAX_ACQUIRE_RELEASE_FENCE_COUNT: i32 = 16;

/// A maximum of 64 child transforms is enough for the expected usage of these APIs. Callers may
/// beyond this limit using [`AddChild`].
pub const MAX_CHILD_TRANSFORMS: i32 = 64;

/// A maximum of 64 hit regions is enough for the expected usage of these APIs.
pub const MAX_HIT_REGION_COUNT: i32 = 64;

pub const MAX_PRESENT_ARGS_FENCE_COUNT: i32 = 16;

/// A maximum of 32 layers per stack is enough for the expected usage of these APIs.
pub const MAX_STACK_LAYERS: i32 = 32;

bitflags! {
    /// Bitset which supports all permutations of flips and rotations.  Flips (if any) are performed
    /// first, followed by rotation (if any).
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct FlipThenRotate: u8 {
        /// Flip the image horizontally (across the Y-axis).
        const FLIP_H = 1;
        /// Flip the image vertically (across the X-axis).
        const FLIP_V = 2;
        /// Rotate the image 90 degrees clockwise.
        const ROTATE_90 = 4;
    }
}

impl FlipThenRotate {}

bitflags! {
    /// The possible usages for a registered buffer collection. Can be a combination of options.
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct RegisterBufferCollectionUsages: u16 {
        /// The specified buffer collection can be used for Flatland and GFX image creation.
        ///
        /// See [`fuchsia.ui.composition/Flatland.CreateImage`] for more.
        const DEFAULT = 1;
        /// The specified buffer collection can be used for screenshotting purposes.
        const SCREENSHOT = 2;
    }
}

impl RegisterBufferCollectionUsages {
    #[inline(always)]
    pub fn from_bits_allow_unknown(bits: u16) -> Self {
        Self::from_bits_retain(bits)
    }

    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        self.get_unknown_bits() != 0
    }

    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u16 {
        self.bits() & !Self::all().bits()
    }
}

/// The set of possible blending functions to choose from when determining how an image should
/// be composited on top of other images.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum BlendMode {
    /// Indicates that the source pixels replace the destination pixels. In other words,
    /// the source pixels are treated as opaque, regardless of what alpha values are set.
    Src = 1,
    /// The source pixels are drawn over the destination pixels. The final pixel color
    /// that is displayed is calculated as: C_src + (1.0 - alpha_src) * C_dst).
    SrcOver = 2,
}

impl BlendMode {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::Src),
            2 => Some(Self::SrcOver),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }
}

/// The set of possible blending functions to choose from when determining how an image should
/// be composited on top of other images.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum BlendMode2 {
    /// Indicates that the source pixels replace the destination pixels: source pixel
    /// values, including alpha, are written into the output as-is, without blending
    /// against the destination. A source pixel with partial or zero alpha is stamped
    /// into the output with that alpha intact; it is not treated as opaque.
    /// (This describes the blend function itself; a layer's `opacity` can demote this
    /// mode. See [`LayerProperties.blend_mode`].)
    Replace,
    /// The source pixels are drawn over the destination pixels. The final pixel color
    /// that is displayed is calculated as: C_src + (1.0 - alpha_src) * C_dst.
    PremultipliedAlpha,
    /// The source pixels are drawn over the destination pixels. The final pixel color that is
    /// displayed is calculated as: alpha_src * C_src + (1.0 - alpha_src) * C_dst.
    StraightAlpha,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u32 },
}

/// Pattern that matches an unknown `BlendMode2` member.
#[macro_export]
macro_rules! BlendMode2Unknown {
    () => {
        _
    };
}

impl BlendMode2 {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::Replace),
            2 => Some(Self::PremultipliedAlpha),
            3 => Some(Self::StraightAlpha),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            1 => Self::Replace,
            2 => Self::PremultipliedAlpha,
            3 => Self::StraightAlpha,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::Replace => 1,
            Self::PremultipliedAlpha => 2,
            Self::StraightAlpha => 3,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ChildViewStatus {
    /// The underlying Flatland session has connected its View, called [`Present`], and the
    /// acquisition fences of the [`Present`] call have all be reached, indicating that it has some
    /// content ready to be displayed, and NOT that the child content has actually been shown on the
    /// screen (a common use case is for the parent to wait for the child content to be ready before
    /// attaching the child to the global scene graph).
    ContentHasPresented = 1,
}

impl ChildViewStatus {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::ContentHasPresented),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }
}

/// Selects what a Layer composites: an image, a solid color, or nothing at all.
///
/// `INVISIBLE` is the freshly-created state. An `INVISIBLE` layer keeps its place in any
/// `LayerStack` which references it, but contributes nothing to the frame. Because layer
/// properties are sticky (see [`LayerProperties`]), passing through `INVISIBLE` and back
/// loses nothing.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum CompositionMode {
    Invisible = 1,
    Image = 2,
    SolidColor = 3,
}

impl CompositionMode {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::Invisible),
            2 => Some(Self::Image),
            3 => Some(Self::SolidColor),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }
}

/// The set of error codes returned in [`OnError`]. Any error causes the Flatland channel to be
/// closed.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum FlatlandError {
    /// Indicates that the parameters used in the function calls are invalid.
    BadOperation = 1,
    /// Indicates that `additional_present_credits` field was not properly processed and the client
    /// queued more [`Present`]s than allowed.
    NoPresentsRemaining = 2,
    /// Indicates that the client has overwritten hanging gets in the protocols returned.
    BadHangingGet = 3,
}

impl FlatlandError {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::BadOperation),
            2 => Some(Self::NoPresentsRemaining),
            3 => Some(Self::BadHangingGet),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }
}

/// An error that can occur when using [`fuchsia.ui.composition/FlatlandFactory.CreateFlatland`].
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum FlatlandFactoryError {
    /// Client provided an invalid configuration, so no Flatland session could be created.
    InvalidArgs,
    /// The server was unable to establish the Flatland session for an unspecified reason
    /// that is not the client's fault.
    Internal,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u32 },
}

/// Pattern that matches an unknown `FlatlandFactoryError` member.
#[macro_export]
macro_rules! FlatlandFactoryErrorUnknown {
    () => {
        _
    };
}

impl FlatlandFactoryError {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::InvalidArgs),
            2 => Some(Self::Internal),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            1 => Self::InvalidArgs,
            2 => Self::Internal,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::InvalidArgs => 1,
            Self::Internal => 2,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

/// The kind of hit test interaction expected for a hit region.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum HitTestInteraction {
    /// The natural default behavior is for a hit region to interact with both regular hit testing
    /// and accessibility hit testing.
    Default,
    /// Some use cases require that a hit region to interact with regular hit testing, but not
    /// interact with accessibility hit testing. Here, "semantics" refers to accessibility's
    /// semantic tree data, which describes UI elements in a View.
    SemanticallyInvisible,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u8 },
}

/// Pattern that matches an unknown `HitTestInteraction` member.
#[macro_export]
macro_rules! HitTestInteractionUnknown {
    () => {
        _
    };
}

impl HitTestInteraction {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            0 => Some(Self::Default),
            1 => Some(Self::SemanticallyInvisible),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
        match prim {
            0 => Self::Default,
            1 => Self::SemanticallyInvisible,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        match self {
            Self::Default => 0,
            Self::SemanticallyInvisible => 1,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

/// The set of possible image flip functions to choose from when determining how the image texture
/// should be displayed.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ImageFlip {
    None = 0,
    /// Let V be the vertical axis of reflection, positioned at width/2. Then each pixel's x
    /// coordinate is reflected across V. The y coordinates remain constant. For instance:
    /// |1234|                |4321|
    /// |abcd|  would become  |dcba|
    LeftRight = 1,
    /// Let H be the horizontal axis of reflection, positioned at height/2. Then each pixel's y
    /// coordinate is reflected across H. The x coordinates remain constant. For instance:
    /// |1234|                |abcd|
    /// |abcd|  would become  |1234|
    UpDown = 2,
}

impl ImageFlip {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::None),
            1 => Some(Self::LeftRight),
            2 => Some(Self::UpDown),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }
}

/// In Flatland, the +X axis is to the right and +Y axis is down. There is no notion of a Z axis.
/// Due to the lack of a Z axis, there is no mathematical notion of "handedness" (either right or
/// left) with respect to rotation. Thus, we define a counter-clockwise rotation in the same way
/// as if a skeuomorphic clock were to be displayed on the screen, with the hands of said clock
/// moving in a CCW motion from the POV of the observer.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum Orientation {
    Ccw0Degrees = 1,
    Ccw90Degrees = 2,
    Ccw180Degrees = 3,
    Ccw270Degrees = 4,
}

impl Orientation {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::Ccw0Degrees),
            2 => Some(Self::Ccw90Degrees),
            3 => Some(Self::Ccw180Degrees),
            4 => Some(Self::Ccw270Degrees),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }
}

/// ParentViewportWatchers will be informed when they are actively attached to a output display
/// (either directly, or through a chain of parent Viewports) and when they are not. Until they are
/// connected to a display, some pieces of information (such as pixel scale) may be unavailable.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ParentViewportStatus {
    ConnectedToDisplay = 1,
    DisconnectedFromDisplay = 2,
}

impl ParentViewportStatus {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::ConnectedToDisplay),
            2 => Some(Self::DisconnectedFromDisplay),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }
}

/// The set of error codes returned by Allocator::RegisterBufferCollection().
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum RegisterBufferCollectionError {
    BadOperation = 1,
}

impl RegisterBufferCollectionError {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::BadOperation),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }
}

/// The possible usages for registered buffer collection.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum RegisterBufferCollectionUsage {
    /// DEFAULT means that the specified buffer collection will be used for
    /// Flatland and gfx image creation.
    ///
    /// See [`fuchsia.ui.composition/Flatland.CreateImage`] for more.
    Default = 0,
    /// SCREENSHOT means that the specified buffer collection will be used for
    /// screenshotting purposes.
    Screenshot = 1,
}

impl RegisterBufferCollectionUsage {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Default),
            1 => Some(Self::Screenshot),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }
}

/// The rotation to be applied to the image.
///
/// If a given display is rotated, say, 270 degrees according to its
/// `display_info` config file, then applying the equal and opposite rotation,
/// [`CW_270_DEGREES`], should cancel the display rotation leading to a
/// correctly rendered screenshot.
///
/// Clients should allocate an image according to the final dimensions they
/// ultimately want to use, i.e. after rotation. These would be identical
/// to the `width` and `height` values found in the `display_info` config file.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum Rotation {
    Cw0Degrees = 0,
    Cw90Degrees = 1,
    Cw180Degrees = 2,
    Cw270Degrees = 3,
}

impl Rotation {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Cw0Degrees),
            1 => Some(Self::Cw90Degrees),
            2 => Some(Self::Cw180Degrees),
            3 => Some(Self::Cw270Degrees),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }
}

/// The possible errors from the ScreenCapture protocol.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum ScreenCaptureError {
    /// One or more required arguments are missing in the table argument.
    MissingArgs,
    /// One or more of the arguments was not valid.
    InvalidArgs,
    /// A general error occurred during the method call.
    BadOperation,
    /// Error that is returned if [`GetNextFrame`] is called when all of the VMOs in the
    /// BufferCollection have been rendered to. [`ReleaseFrame`] must be called before a
    /// successful call to GetNextFrame can be made.
    BufferFull,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u32 },
}

/// Pattern that matches an unknown `ScreenCaptureError` member.
#[macro_export]
macro_rules! ScreenCaptureErrorUnknown {
    () => {
        _
    };
}

impl ScreenCaptureError {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::MissingArgs),
            2 => Some(Self::InvalidArgs),
            3 => Some(Self::BadOperation),
            4 => Some(Self::BufferFull),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            1 => Self::MissingArgs,
            2 => Self::InvalidArgs,
            3 => Self::BadOperation,
            4 => Self::BufferFull,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::MissingArgs => 1,
            Self::InvalidArgs => 2,
            Self::BadOperation => 3,
            Self::BufferFull => 4,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

/// The different formats of Screenshot that can be requested.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum ScreenshotFormat {
    /// The default format, requesting a tightly packed pixel data with 32 bit BGRA pixels.
    BgraRaw,
    /// Requests tightly packed pixel data with 32 bit RGBA pixels.
    RgbaRaw,
    /// Requests tightly packed pixel data which is compressed into PNG format.
    Png,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u8 },
}

/// Pattern that matches an unknown `ScreenshotFormat` member.
#[macro_export]
macro_rules! ScreenshotFormatUnknown {
    () => {
        _
    };
}

impl ScreenshotFormat {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            0 => Some(Self::BgraRaw),
            2 => Some(Self::RgbaRaw),
            1 => Some(Self::Png),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
        match prim {
            0 => Self::BgraRaw,
            2 => Self::RgbaRaw,
            1 => Self::Png,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        match self {
            Self::BgraRaw => 0,
            Self::RgbaRaw => 2,
            Self::Png => 1,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

/// An error that can occur when using the [TrustedFlatlandFactory].
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum TrustedFlatlandFactoryError {
    /// A general error occurred during the method call. This may happen if the configuration
    /// is invalid or if the system is unable to create a new Flatland session.
    BadOperation,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u32 },
}

/// Pattern that matches an unknown `TrustedFlatlandFactoryError` member.
#[macro_export]
macro_rules! TrustedFlatlandFactoryErrorUnknown {
    () => {
        _
    };
}

impl TrustedFlatlandFactoryError {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::BadOperation),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            1 => Self::BadOperation,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::BadOperation => 1,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ChildViewWatcherGetStatusResponse {
    pub status: ChildViewStatus,
}

impl fidl::Persistable for ChildViewWatcherGetStatusResponse {}

/// Represents a color with alpha channel.
/// Values are unorm (i.e. the valid range is [0,1]), and are in linear color
/// space. They are not gamma-corrected nor premultiplied.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct ColorRgba {
    pub red: f32,
    pub green: f32,
    pub blue: f32,
    pub alpha: f32,
}

impl fidl::Persistable for ColorRgba {}

/// A user-defined identifier for a particular piece of Content. See Content creation functions
/// (e.g. [`CreateViewport`], [`CreateImage`]) for more information.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ContentId {
    pub value: u64,
}

impl fidl::Persistable for ContentId {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Flatland2CreateLayerRequest {
    pub layer_id: LayerId,
}

impl fidl::Persistable for Flatland2CreateLayerRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Flatland2CreateLayerStackRequest {
    pub stack_id: LayerStackId,
}

impl fidl::Persistable for Flatland2CreateLayerStackRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Flatland2ReleaseImage2Request {
    pub image_id: ImageId,
}

impl fidl::Persistable for Flatland2ReleaseImage2Request {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Flatland2ReleaseLayerRequest {
    pub layer_id: LayerId,
}

impl fidl::Persistable for Flatland2ReleaseLayerRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Flatland2ReleaseLayerStackRequest {
    pub stack_id: LayerStackId,
}

impl fidl::Persistable for Flatland2ReleaseLayerStackRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Flatland2ReleaseViewport2Request {
    pub viewport_id: ViewportId,
}

impl fidl::Persistable for Flatland2ReleaseViewport2Request {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct Flatland2ResetLayerRequest {
    pub layer_id: LayerId,
}

impl fidl::Persistable for Flatland2ResetLayerRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct Flatland2SetLayerPropertiesRequest {
    pub layer_id: LayerId,
    pub properties: LayerProperties,
}

impl fidl::Persistable for Flatland2SetLayerPropertiesRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Flatland2SetStackLayersRequest {
    pub stack_id: LayerStackId,
    pub layers: Vec<LayerId>,
}

impl fidl::Persistable for Flatland2SetStackLayersRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Flatland2SetTransformContentRequest {
    pub transform_id: TransformId,
    pub content: Option<Box<TransformContent>>,
}

impl fidl::Persistable for Flatland2SetTransformContentRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct Flatland2SetViewportProperties2Request {
    pub viewport_id: ViewportId,
    pub properties: ViewportProperties,
}

impl fidl::Persistable for Flatland2SetViewportProperties2Request {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FlatlandAddChildRequest {
    pub parent_transform_id: TransformId,
    pub child_transform_id: TransformId,
}

impl fidl::Persistable for FlatlandAddChildRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FlatlandCreateTransformRequest {
    pub transform_id: TransformId,
}

impl fidl::Persistable for FlatlandCreateTransformRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct FlatlandDisplaySetDevicePixelRatioRequest {
    pub device_pixel_ratio: fidl_fuchsia_math_common::VecF,
}

impl fidl::Persistable for FlatlandDisplaySetDevicePixelRatioRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FlatlandOnErrorRequest {
    pub error: FlatlandError,
}

impl fidl::Persistable for FlatlandOnErrorRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct FlatlandOnFramePresentedRequest {
    pub frame_presented_info: fidl_fuchsia_scenic_scheduling_common::FramePresentedInfo,
}

impl fidl::Persistable for FlatlandOnFramePresentedRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct FlatlandOnNextFrameBeginRequest {
    pub values: OnNextFrameBeginValues,
}

impl fidl::Persistable for FlatlandOnNextFrameBeginRequest {}

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

impl fidl::Persistable for FlatlandReleaseFilledRectRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FlatlandReleaseImageRequest {
    pub image_id: ContentId,
}

impl fidl::Persistable for FlatlandReleaseImageRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FlatlandReleaseTransformRequest {
    pub transform_id: TransformId,
}

impl fidl::Persistable for FlatlandReleaseTransformRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FlatlandReleaseViewportRequest {
    pub viewport_id: ContentId,
}

impl fidl::Persistable for FlatlandReleaseViewportRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FlatlandRemoveChildRequest {
    pub parent_transform_id: TransformId,
    pub child_transform_id: TransformId,
}

impl fidl::Persistable for FlatlandRemoveChildRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FlatlandReplaceChildrenRequest {
    pub parent_transform_id: TransformId,
    pub new_child_transform_ids: Vec<TransformId>,
}

impl fidl::Persistable for FlatlandReplaceChildrenRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct FlatlandSetClipBoundaryRequest {
    pub transform_id: TransformId,
    pub rect: Option<Box<fidl_fuchsia_math_common::Rect>>,
}

impl fidl::Persistable for FlatlandSetClipBoundaryRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FlatlandSetContentRequest {
    pub transform_id: TransformId,
    pub content_id: ContentId,
}

impl fidl::Persistable for FlatlandSetContentRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FlatlandSetDebugNameRequest {
    pub name: String,
}

impl fidl::Persistable for FlatlandSetDebugNameRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct FlatlandSetHitRegionsRequest {
    pub transform_id: TransformId,
    /// Each region's [`HitRegion.region.width`] and [`HitRegion.region.height`] field must be a
    /// non-negative value.
    pub regions: Vec<HitRegion>,
}

impl fidl::Persistable for FlatlandSetHitRegionsRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FlatlandSetImageBlendModeRequest {
    pub image_id: ContentId,
    pub blend_mode: BlendMode2,
}

impl fidl::Persistable for FlatlandSetImageBlendModeRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FlatlandSetImageBlendingFunctionRequest {
    pub image_id: ContentId,
    pub blend_mode: BlendMode,
}

impl fidl::Persistable for FlatlandSetImageBlendingFunctionRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct FlatlandSetImageDestinationSizeRequest {
    pub image_id: ContentId,
    pub size: fidl_fuchsia_math_common::SizeU,
}

impl fidl::Persistable for FlatlandSetImageDestinationSizeRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FlatlandSetImageFlipRequest {
    pub image_id: ContentId,
    pub flip: ImageFlip,
}

impl fidl::Persistable for FlatlandSetImageFlipRequest {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct FlatlandSetImageOpacityRequest {
    pub image_id: ContentId,
    pub val: f32,
}

impl fidl::Persistable for FlatlandSetImageOpacityRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct FlatlandSetImageSampleRegionRequest {
    pub image_id: ContentId,
    pub rect: fidl_fuchsia_math_common::RectF,
}

impl fidl::Persistable for FlatlandSetImageSampleRegionRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FlatlandSetInfiniteHitRegionRequest {
    pub transform_id: TransformId,
    pub hit_test: HitTestInteraction,
}

impl fidl::Persistable for FlatlandSetInfiniteHitRegionRequest {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct FlatlandSetOpacityRequest {
    pub transform_id: TransformId,
    pub value: f32,
}

impl fidl::Persistable for FlatlandSetOpacityRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FlatlandSetOrientationRequest {
    pub transform_id: TransformId,
    pub orientation: Orientation,
}

impl fidl::Persistable for FlatlandSetOrientationRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FlatlandSetRootTransformRequest {
    pub transform_id: TransformId,
}

impl fidl::Persistable for FlatlandSetRootTransformRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct FlatlandSetScaleRequest {
    pub transform_id: TransformId,
    pub scale: fidl_fuchsia_math_common::VecF,
}

impl fidl::Persistable for FlatlandSetScaleRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct FlatlandSetTranslationRequest {
    pub transform_id: TransformId,
    pub translation: fidl_fuchsia_math_common::Vec_,
}

impl fidl::Persistable for FlatlandSetTranslationRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct FlatlandSetViewportPropertiesRequest {
    pub viewport_id: ContentId,
    pub properties: ViewportProperties,
}

impl fidl::Persistable for FlatlandSetViewportPropertiesRequest {}

/// An interactive area of a View, placed in the coordinate space of a specific Transform.
#[derive(Clone, Debug, PartialEq)]
pub struct HitRegion {
    /// The position and size of this hit region, in the coordinate space of the Transform that owns
    /// this hit region.
    pub region: fidl_fuchsia_math_common::RectF,
    /// The interaction behavior specified for this hit region.
    /// To specify "no interaction at all", remove this hit region from the owning Transform.
    pub hit_test: HitTestInteraction,
}

impl fidl::Persistable for HitRegion {}

/// A user-defined identifier for a particular image created with [`Flatland.CreateImage2`].
///
/// Zero is never a valid `ImageId`; the shared identifier rules documented on
/// [`LayerId`] also apply.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ImageId {
    pub value: u64,
}

impl fidl::Persistable for ImageId {}

/// **Zero identifiers**: zero is never a valid identifier, for any of these types; each
/// `Create*` method rejects it. Unlike the classic API (where, e.g., [`Flatland.SetContent`]
/// accepts id 0 to clear a Transform's content), Flatland2 never uses a zero id to express
/// clearing; where clearing is possible, it is expressed by omitting an optional field
/// (see [`Flatland.SetTransformContent`]).
///
/// A user-defined identifier for a particular layer. See [`Flatland.CreateLayer`] and
/// [`Flatland.ReleaseLayer`] for more information.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct LayerId {
    pub value: u64,
}

impl fidl::Persistable for LayerId {}

/// A user-defined identifier for a particular layer stack created with [`Flatland.CreateLayerStack`].
///
/// Zero is never a valid `LayerStackId`; the shared identifier rules documented on
/// [`LayerId`] also apply.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct LayerStackId {
    pub value: u64,
}

impl fidl::Persistable for LayerStackId {}

#[derive(Clone, Debug, PartialEq)]
pub struct ParentViewportWatcherGetLayoutResponse {
    pub info: LayoutInfo,
}

impl fidl::Persistable for ParentViewportWatcherGetLayoutResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ParentViewportWatcherGetStatusResponse {
    pub status: ParentViewportStatus,
}

impl fidl::Persistable for ParentViewportWatcherGetStatusResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ScreenCaptureReleaseFrameRequest {
    pub buffer_id: u32,
}

impl fidl::Persistable for ScreenCaptureReleaseFrameRequest {}

/// A user-defined identifier for a particular transform. See [`CreateTransform`] and
/// [`ReleaseTransform`] for more information.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct TransformId {
    pub value: u64,
}

impl fidl::Persistable for TransformId {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct TrustedFlatlandReleaseImageImmediately2Request {
    pub image_id: ImageId,
}

impl fidl::Persistable for TrustedFlatlandReleaseImageImmediately2Request {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct TrustedFlatlandReleaseImageImmediatelyRequest {
    pub image_id: ContentId,
}

impl fidl::Persistable for TrustedFlatlandReleaseImageImmediatelyRequest {}

/// A user-defined identifier for a particular viewport created with [`Flatland.CreateViewport2`].
///
/// Zero is never a valid `ViewportId`; the shared identifier rules documented on
/// [`LayerId`] also apply.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ViewportId {
    pub value: u64,
}

impl fidl::Persistable for ViewportId {}

/// Configuration parameters for instantiating a regular Flatland session.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct FlatlandConfig {
    /// If true, opts the session into the Flatland2 API surface and layer data model.
    /// Defaults to false.
    pub use_flatland2: Option<bool>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for FlatlandConfig {}

/// The properties of an Image as defined by the client. These properties determine how an Image
/// uses the backing BufferCollection. See [`CreateImage`] for more information.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ImageProperties {
    /// The size of the Image in pixels.
    pub size: Option<fidl_fuchsia_math_common::SizeU>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for ImageProperties {}

/// Stateful properties associated with a Layer.
///
/// All fields are sticky: [`SetLayerProperties`] merges the provided table into the
/// layer's stored properties, and stored values persist across [`SetLayerImage`] calls
/// and across composition mode changes. Fields not used by the current composition mode
/// keep their values, and take effect again when a mode that uses them is re-entered.
/// Nothing is cleared implicitly; [`ResetLayer`] is the only operation that forgets
/// stored properties.
///
/// **Hints (Safety and Performance Semantics)**:
/// Hints (such as [`hint_damage_rects`] and [`hint_visible_rects`]) are optional
/// optimization details provided by the client.
/// * **Ignorable by Design**: The implementation is free to ignore these hints. If ignored,
///   rendering remains fully correct, though possibly less optimal.
/// * **Correct Hints**: Yield the identical visual result but may improve performance (e.g.,
///   by allowing composition shortcuts or partial updates).
/// * **Incorrect Hints**: May result in rendering artifacts, stale regions, or incorrect
///   pixels on the display, as the implementation might optimize based on false assumptions.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct LayerProperties {
    /// The rectangle where the layer content will be displayed in its local coordinate space.
    ///
    /// For image layers, visual properties are applied in the following order:
    /// 1. **Sample**: The region specified by `sample_rect` is extracted from the image.
    /// 2. **Transform**: The sampled region is flipped and rotated as specified by `transform`.
    /// 3. **Scale/Fit**: Transformed content is implicitly scaled to fit the `display_rect`.
    ///
    /// Hardware image scaling is requested implicitly when the dimensions of the transformed
    /// `sample_rect` differ from the extent of the `display_rect`. Not all display hardware supports
    /// scaling, or may have limitations.
    ///
    /// The dimensions of `display_rect` must account for image dimension changes caused by rotations
    /// to avoid implicit scaling or distortion. For example, rotating a 600x300 pixel region
    /// by 90 degrees would require specifying 300x600 dimensions here to maintain the aspect ratio.
    ///
    /// **Note**: This rectangle is specified in the local space of the LayerStack (or the Transform
    /// the LayerStack is attached to). Any scaling applied by parent transforms in the Flatland scene
    /// graph will further affect the final size on the physical display.
    ///
    /// Default: (0,0,0,0). The layer will not be visible until a rectangle with non-zero
    /// width and height is set.
    pub display_rect: Option<fidl_fuchsia_math_common::RectU>,
    /// The opacity of the layer, in the range [0..1].
    ///
    /// Multiplies with opacity inherited from `Transform`s above the layer's `LayerStack`
    /// (see [`fuchsia.ui.composition/Flatland.SetOpacity`]) to give the layer's *effective
    /// opacity*. The layer renders as if its content's own alpha (image pixels' alpha, or
    /// `color.alpha` for a solid-color layer) were scaled by the effective opacity; since
    /// this requires blending, a `REPLACE` layer with effective opacity below 1.0 renders
    /// as `PREMULTIPLIED_ALPHA` (see [`blend_mode`]). A layer with effective opacity 0.0
    /// is invisible.
    ///
    /// Default: 1.0 (the content's own alpha applies unmodified).
    pub opacity: Option<f32>,
    /// The blend mode used to composite the layer over the content beneath it.
    ///
    /// `REPLACE` is honored only while the layer's effective opacity is 1.0 (see [`opacity`]);
    /// at lower effective opacity the layer renders as `PREMULTIPLIED_ALPHA`, so that opacity
    /// always fades the layer. To write exact sub-unity alpha values into the output (e.g.
    /// punching a hole for an underlay), author them in the content itself (the image's own
    /// pixels, or `color.alpha` for a solid-color layer) and leave `opacity` at 1.0.
    ///
    /// `STRAIGHT_ALPHA` names a content *encoding*, and is meaningful for image
    /// content. A solid-color layer's encoding is fixed by the API (`color` is straight
    /// RGBA regardless of `blend_mode`), so for solid-color content `STRAIGHT_ALPHA` is
    /// accepted and composites identically to `PREMULTIPLIED_ALPHA`.
    ///
    /// Default: `BlendMode2.REPLACE`.
    pub blend_mode: Option<BlendMode2>,
    /// The color to fill the layer with, as straight (non-premultiplied) RGBA regardless
    /// of `blend_mode`. The compositor performs any conversion needed for rendering.
    ///
    /// Default: opaque white (1.0, 1.0, 1.0, 1.0).
    pub color: Option<ColorRgba>,
    /// Describes the region inside the image to sample from, in unnormalized coordinates
    /// (rect width/height match image width/height).
    ///
    /// Default: (0,0,0,0), which is interpreted as the entire image region.  A client can
    /// reset to the full image by setting this field to (0,0,0,0).
    ///
    /// Must lie within the bounds of the bound image. This is checked during
    /// [`fuchsia.ui.composition/Flatland.Present`], and only for layers whose
    /// `composition_mode` is `IMAGE`, so the order of calls within a batch does not
    /// matter: a rect and an image of matching size may be set in either order, and a
    /// rect set while no image is bound (or while another mode is in effect) is stored
    /// without complaint. A violation at `Present` closes the connection with
    /// `BAD_OPERATION`.
    pub sample_rect: Option<fidl_fuchsia_math_common::RectF>,
    /// Specifies image transform.
    ///
    /// Default: No transformation (identity).
    pub transform: Option<FlipThenRotate>,
    /// A hint describing the region of the source image that has changed since the last frame.
    /// Specified in the coordinate space of the source image (buffer).
    ///
    /// Default: Empty vector (interpreted as the entire sample rect being damaged).
    ///
    /// Refer to [`LayerProperties`] for the general safety and performance semantics of hints.
    pub hint_damage_rects: Option<Vec<fidl_fuchsia_math_common::RectU>>,
    /// A hint describing the visible region of the layer on the screen.
    /// Specified in the local coordinate space of the Layer (matching `display_rect`).
    ///
    /// Default: Empty vector (interpreted as the entire `display_rect` being visible).
    ///
    /// Refer to [`LayerProperties`] for the general safety and performance semantics of hints.
    pub hint_visible_rects: Option<Vec<fidl_fuchsia_math_common::RectU>>,
    /// Selects which of the property groups above is in effect; see [`CompositionMode`].
    ///
    /// Default: `CompositionMode.INVISIBLE`.
    pub composition_mode: Option<CompositionMode>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for LayerProperties {}

/// The return type of [`GetLayout`]. This table contains most of the information necessary
/// for a client to decide how to layout their content in a Flatland session. This data may be
/// provided to the client before the command that creates the View is presented, so that the
/// client may lay out content properly before their first call to [`Present`].
#[derive(Clone, Debug, Default, PartialEq)]
pub struct LayoutInfo {
    /// The layout size of a View in logical pixels, defined by the parent's call to
    /// [`SetViewportProperties`].
    ///
    /// The logical size also serves as the clip boundary of the View. Anything outside the clip
    /// boundary will not be rendered. Hence, the View's Root Transform has a useful coordinate
    /// space of (0, 0) to (logical_size.width, logical_size.height).
    ///
    /// Clients should re-layout their content when this value changes.
    pub logical_size: Option<fidl_fuchsia_math_common::SizeU>,
    /// The ratio of display's physical pixels to device independent pixels. Each logical pixel of a
    /// View is displayed on-screen by one or more physical pixels, as determined by this scale.
    /// Clients should not necessarily re-layout their content when this value changes, but
    /// accommodate by reallocating their Image buffers to avoid sampling artifacts. The HiDPI-aware
    /// client should allocate buffers that are sized (`logical_size`*`device_pixel_ratio`).
    pub device_pixel_ratio: Option<fidl_fuchsia_math_common::VecF>,
    /// The offsets between the edges and the visible rectangle of the View. The clients can assume
    /// that the boundary region between the inset and the View edge is occluded, and should adjust
    /// content layout to avoid this region. This inset is described in the view's logical
    /// coordinate system. The HiDPI-aware clients should scale this by `device_pixel_ratio`.
    pub inset: Option<fidl_fuchsia_math_common::Inset>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for LayoutInfo {}

/// Fields that a client needs in order to produce its next frame, returned in
/// [`OnNextFrameBegin`]. Each field is guaranteed to be  set and contain valid information.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct OnNextFrameBeginValues {
    /// The number of *additional* [`Present`] calls allowed to the client so that they
    /// can call [`Present`] further times. This is a delta in the present
    /// credit budget, not the absolute number of present credits.
    pub additional_present_credits: Option<u32>,
    /// Information about future presentation and latch times that a client may aim for
    /// precise scheduling behavior.
    pub future_presentation_infos:
        Option<Vec<fidl_fuchsia_scenic_scheduling_common::PresentationInfo>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for OnNextFrameBeginValues {}

/// The properties of a Viewport as defined by the parent. This data, along with the set of attached
/// Transforms, will be used to compute the LayoutInfo for the View of the Viewport.
/// `ViewportProperties` must have `logical_size` set at least once. This is the initial size that
/// will drive the layout of the child.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ViewportProperties {
    /// The size of the Viewport in logical pixels. This maps directly to the logical_size field in
    /// LayoutInfo. The valid logical_size must have positive X and Y components.
    pub logical_size: Option<fidl_fuchsia_math_common::SizeU>,
    /// The offsets between the edges and the visible rectangle of the Viewport. This maps directly
    /// to the `inset` field in LayoutInfo. The valid inset must have all components greater than or
    /// equal to 0.
    pub inset: Option<fidl_fuchsia_math_common::Inset>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for ViewportProperties {}

/// Content that can be attached to a Transform when Flatland2 is enabled.
///
/// This union defines the types of content that can be attached to a Transform
/// using [`Flatland.SetTransformContent`].
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum TransformContent {
    LayerStack(LayerStackId),
    Viewport(ViewportId),
}

impl TransformContent {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::LayerStack(_) => 1,
            Self::Viewport(_) => 2,
        }
    }
}

impl fidl::Persistable for TransformContent {}

pub mod allocator_ordinals {
    pub const REGISTER_BUFFER_COLLECTION: u64 = 0x494b7ea578d1061e;
}

pub mod child_view_watcher_ordinals {
    pub const GET_STATUS: u64 = 0x1d622075f4fc8243;
    pub const GET_VIEW_REF: u64 = 0x3b2f3ca31e8908b4;
}

pub mod flatland_ordinals {
    pub const RELEASE_IMAGE_IMMEDIATELY: u64 = 0x245e1ac080772c8;
    pub const RELEASE_IMAGE_IMMEDIATELY2: u64 = 0x6d6a73d150589146;
    pub const CREATE_LAYER: u64 = 0x60837bb0ce59f8a9;
    pub const RELEASE_LAYER: u64 = 0x60118a842b6f0756;
    pub const SET_LAYER_IMAGE: u64 = 0x262302d9782d252c;
    pub const SET_LAYER_PROPERTIES: u64 = 0x282d0e902aae8bb0;
    pub const RESET_LAYER: u64 = 0x17bf541bf216ab2b;
    pub const CREATE_LAYER_STACK: u64 = 0x70debe3cd7371aa6;
    pub const RELEASE_LAYER_STACK: u64 = 0x3ad3151aece3b1bb;
    pub const SET_STACK_LAYERS: u64 = 0x1e0bff0f5cca065a;
    pub const CREATE_IMAGE2: u64 = 0x677fa7b23aaca46;
    pub const RELEASE_IMAGE2: u64 = 0x7d0a041ed51aca06;
    pub const CREATE_VIEWPORT2: u64 = 0x1b646776764f1128;
    pub const RELEASE_VIEWPORT2: u64 = 0x18ef77414c7a9ae3;
    pub const SET_VIEWPORT_PROPERTIES2: u64 = 0x95f2ec3b9e4beea;
    pub const SET_TRANSFORM_CONTENT: u64 = 0x17e33f64f55e4ea9;
    pub const PRESENT: u64 = 0x50acc2aa1f0acec7;
    pub const ON_NEXT_FRAME_BEGIN: u64 = 0x10f69a5cdeece84a;
    pub const ON_FRAME_PRESENTED: u64 = 0x56e43e1a5f30216d;
    pub const ON_ERROR: u64 = 0x1ebf39e90cd8b8d;
    pub const CREATE_VIEW: u64 = 0x504686eb25864780;
    pub const CREATE_VIEW2: u64 = 0x340a3a40c2fdbd5e;
    pub const CREATE_TRANSFORM: u64 = 0x5e042a4d3de3efb0;
    pub const SET_TRANSLATION: u64 = 0x7863398291fba346;
    pub const SET_ORIENTATION: u64 = 0x4915310bc4928edc;
    pub const SET_SCALE: u64 = 0x1ea1766fd8996bb4;
    pub const SET_OPACITY: u64 = 0x3775fc2c00b432fa;
    pub const SET_CLIP_BOUNDARY: u64 = 0x6507843df12222d2;
    pub const ADD_CHILD: u64 = 0x67a8abd2f19b1a74;
    pub const REMOVE_CHILD: u64 = 0x41d6cd90b298b67a;
    pub const REPLACE_CHILDREN: u64 = 0x5b6d86cbbff81316;
    pub const SET_ROOT_TRANSFORM: u64 = 0x6e80ca5bcc566cd8;
    pub const SET_HIT_REGIONS: u64 = 0x31c9d17b07c37ce4;
    pub const SET_INFINITE_HIT_REGION: u64 = 0x26d81af852d29562;
    pub const CREATE_VIEWPORT: u64 = 0x2485fbcab7f943c;
    pub const CREATE_IMAGE: u64 = 0x26fae823c4ebedad;
    pub const SET_IMAGE_SAMPLE_REGION: u64 = 0x8039391d715eb28;
    pub const SET_IMAGE_DESTINATION_SIZE: u64 = 0x766cf99a2ec58446;
    pub const SET_IMAGE_BLENDING_FUNCTION: u64 = 0x10f5da1356275b7b;
    pub const SET_IMAGE_BLEND_MODE: u64 = 0x5b1667f130c3de67;
    pub const SET_IMAGE_OPACITY: u64 = 0x2da9e4ef4c2cff6f;
    pub const SET_IMAGE_FLIP: u64 = 0x21b20f2c14aae6bc;
    pub const CREATE_FILLED_RECT: u64 = 0x5e62355abc1c4c5d;
    pub const SET_SOLID_FILL: u64 = 0x32d6ef41e182dfa5;
    pub const RELEASE_FILLED_RECT: u64 = 0x7392cabe45618f9b;
    pub const SET_CONTENT: u64 = 0x4ed2cfc0ce130862;
    pub const SET_VIEWPORT_PROPERTIES: u64 = 0x66ab67e9608ddb9f;
    pub const RELEASE_TRANSFORM: u64 = 0xab9328419451c22;
    pub const RELEASE_VIEW: u64 = 0x5b35aab9baffecae;
    pub const RELEASE_VIEWPORT: u64 = 0xbad474aeb5293f9;
    pub const RELEASE_IMAGE: u64 = 0xb884ffdbc72c111;
    pub const CLEAR: u64 = 0x4ec8817c02828c3e;
    pub const SET_DEBUG_NAME: u64 = 0x46a8b397e68a8888;
}

pub mod flatland2_ordinals {
    pub const CREATE_LAYER: u64 = 0x60837bb0ce59f8a9;
    pub const RELEASE_LAYER: u64 = 0x60118a842b6f0756;
    pub const SET_LAYER_IMAGE: u64 = 0x262302d9782d252c;
    pub const SET_LAYER_PROPERTIES: u64 = 0x282d0e902aae8bb0;
    pub const RESET_LAYER: u64 = 0x17bf541bf216ab2b;
    pub const CREATE_LAYER_STACK: u64 = 0x70debe3cd7371aa6;
    pub const RELEASE_LAYER_STACK: u64 = 0x3ad3151aece3b1bb;
    pub const SET_STACK_LAYERS: u64 = 0x1e0bff0f5cca065a;
    pub const CREATE_IMAGE2: u64 = 0x677fa7b23aaca46;
    pub const RELEASE_IMAGE2: u64 = 0x7d0a041ed51aca06;
    pub const CREATE_VIEWPORT2: u64 = 0x1b646776764f1128;
    pub const RELEASE_VIEWPORT2: u64 = 0x18ef77414c7a9ae3;
    pub const SET_VIEWPORT_PROPERTIES2: u64 = 0x95f2ec3b9e4beea;
    pub const SET_TRANSFORM_CONTENT: u64 = 0x17e33f64f55e4ea9;
}

pub mod flatland_display_ordinals {
    pub const SET_CONTENT: u64 = 0x6748193a39918298;
    pub const SET_DEVICE_PIXEL_RATIO: u64 = 0x392c3e70cc0a81a4;
}

pub mod flatland_factory_ordinals {
    pub const CREATE_FLATLAND: u64 = 0x5de80d9d7239b37e;
}

pub mod parent_viewport_watcher_ordinals {
    pub const GET_LAYOUT: u64 = 0x3cbe5d9638e032;
    pub const GET_STATUS: u64 = 0x7caa022f050d9ea6;
}

pub mod screen_capture_ordinals {
    pub const CONFIGURE: u64 = 0x3b6e5af1d294afd9;
    pub const GET_NEXT_FRAME: u64 = 0x552c1580aab8c4a7;
    pub const RELEASE_FRAME: u64 = 0x46704dce24e35950;
}

pub mod screenshot_ordinals {
    pub const TAKE: u64 = 0x51341396e9fd2fd0;
    pub const TAKE_FILE: u64 = 0x470aeea0a4d32903;
}

pub mod trusted_flatland_ordinals {
    pub const RELEASE_IMAGE_IMMEDIATELY: u64 = 0x245e1ac080772c8;
    pub const RELEASE_IMAGE_IMMEDIATELY2: u64 = 0x6d6a73d150589146;
}

pub mod trusted_flatland_factory_ordinals {
    pub const CREATE_FLATLAND: u64 = 0x48e89c53f00561dc;
}

mod internal {
    use super::*;
    unsafe impl fidl::encoding::TypeMarker for FlipThenRotate {
        type Owned = Self;

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

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

    impl fidl::encoding::ValueTypeMarker for FlipThenRotate {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for FlipThenRotate {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            if self.bits() & Self::all().bits() != self.bits() {
                return Err(fidl::Error::InvalidBitsValue);
            }
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FlipThenRotate {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u8>(offset);
            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for RegisterBufferCollectionUsages {
        type Owned = Self;

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

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

    impl fidl::encoding::ValueTypeMarker for RegisterBufferCollectionUsages {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for RegisterBufferCollectionUsages
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for RegisterBufferCollectionUsages
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u16>(offset);
            *self = Self::from_bits_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for BlendMode {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

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

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

    impl fidl::encoding::ValueTypeMarker for BlendMode {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for BlendMode {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BlendMode {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Src
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for BlendMode2 {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

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

    impl fidl::encoding::ValueTypeMarker for BlendMode2 {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for BlendMode2 {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BlendMode2 {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ChildViewStatus {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

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

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

    impl fidl::encoding::ValueTypeMarker for ChildViewStatus {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for ChildViewStatus
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChildViewStatus {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::ContentHasPresented
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for CompositionMode {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

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

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

    impl fidl::encoding::ValueTypeMarker for CompositionMode {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for CompositionMode
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositionMode {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Invisible
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for FlatlandError {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

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

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

    impl fidl::encoding::ValueTypeMarker for FlatlandError {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for FlatlandError {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FlatlandError {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::BadOperation
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for FlatlandFactoryError {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

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

    impl fidl::encoding::ValueTypeMarker for FlatlandFactoryError {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for FlatlandFactoryError
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FlatlandFactoryError {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for HitTestInteraction {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u8>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u8>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

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

    impl fidl::encoding::ValueTypeMarker for HitTestInteraction {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for HitTestInteraction
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HitTestInteraction {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u8>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ImageFlip {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

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

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

    impl fidl::encoding::ValueTypeMarker for ImageFlip {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ImageFlip {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ImageFlip {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::None
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for Orientation {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

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

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

    impl fidl::encoding::ValueTypeMarker for Orientation {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Orientation {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Orientation {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Ccw0Degrees
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ParentViewportStatus {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

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

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

    impl fidl::encoding::ValueTypeMarker for ParentViewportStatus {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for ParentViewportStatus
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ParentViewportStatus {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::ConnectedToDisplay
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for RegisterBufferCollectionError {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

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

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

    impl fidl::encoding::ValueTypeMarker for RegisterBufferCollectionError {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for RegisterBufferCollectionError
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for RegisterBufferCollectionError
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::BadOperation
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for RegisterBufferCollectionUsage {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

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

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

    impl fidl::encoding::ValueTypeMarker for RegisterBufferCollectionUsage {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for RegisterBufferCollectionUsage
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for RegisterBufferCollectionUsage
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Default
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for Rotation {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

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

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

    impl fidl::encoding::ValueTypeMarker for Rotation {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Rotation {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Rotation {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Cw0Degrees
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ScreenCaptureError {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

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

    impl fidl::encoding::ValueTypeMarker for ScreenCaptureError {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for ScreenCaptureError
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScreenCaptureError {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ScreenshotFormat {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u8>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u8>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

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

    impl fidl::encoding::ValueTypeMarker for ScreenshotFormat {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for ScreenshotFormat
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScreenshotFormat {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u8>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for TrustedFlatlandFactoryError {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

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

    impl fidl::encoding::ValueTypeMarker for TrustedFlatlandFactoryError {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for TrustedFlatlandFactoryError
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for TrustedFlatlandFactoryError
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ChildViewWatcherGetStatusResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ChildViewWatcherGetStatusResponse {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ChildViewWatcherGetStatusResponse, D>
        for &ChildViewWatcherGetStatusResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ChildViewWatcherGetStatusResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ChildViewWatcherGetStatusResponse, D>::encode(
                (<ChildViewStatus as fidl::encoding::ValueTypeMarker>::borrow(&self.status),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ChildViewStatus, D>>
        fidl::encoding::Encode<ChildViewWatcherGetStatusResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ChildViewWatcherGetStatusResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ChildViewWatcherGetStatusResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { status: fidl::new_empty!(ChildViewStatus, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for ColorRgba {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ColorRgba, D>
        for &ColorRgba
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ColorRgba>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ColorRgba, D>::encode(
                (
                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.red),
                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.green),
                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.blue),
                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.alpha),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<f32, D>,
        T1: fidl::encoding::Encode<f32, D>,
        T2: fidl::encoding::Encode<f32, D>,
        T3: fidl::encoding::Encode<f32, D>,
    > fidl::encoding::Encode<ColorRgba, D> for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ColorRgba>(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)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 12, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ColorRgba {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                red: fidl::new_empty!(f32, D),
                green: fidl::new_empty!(f32, D),
                blue: fidl::new_empty!(f32, D),
                alpha: fidl::new_empty!(f32, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(f32, D, &mut self.red, decoder, offset + 0, _depth)?;
            fidl::decode!(f32, D, &mut self.green, decoder, offset + 4, _depth)?;
            fidl::decode!(f32, D, &mut self.blue, decoder, offset + 8, _depth)?;
            fidl::decode!(f32, D, &mut self.alpha, decoder, offset + 12, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ContentId {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ContentId {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ContentId, D>
        for &ContentId
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ContentId>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut ContentId).write_unaligned((self as *const ContentId).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<ContentId, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ContentId>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ContentId {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { value: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for Flatland2CreateLayerRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Flatland2CreateLayerRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<Flatland2CreateLayerRequest, D> for &Flatland2CreateLayerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2CreateLayerRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Flatland2CreateLayerRequest)
                    .write_unaligned((self as *const Flatland2CreateLayerRequest).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<LayerId, D>>
        fidl::encoding::Encode<Flatland2CreateLayerRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2CreateLayerRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for Flatland2CreateLayerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { layer_id: fidl::new_empty!(LayerId, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for Flatland2CreateLayerStackRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Flatland2CreateLayerStackRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<Flatland2CreateLayerStackRequest, D>
        for &Flatland2CreateLayerStackRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2CreateLayerStackRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Flatland2CreateLayerStackRequest)
                    .write_unaligned((self as *const Flatland2CreateLayerStackRequest).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<LayerStackId, D>>
        fidl::encoding::Encode<Flatland2CreateLayerStackRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2CreateLayerStackRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for Flatland2CreateLayerStackRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { stack_id: fidl::new_empty!(LayerStackId, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for Flatland2ReleaseImage2Request {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Flatland2ReleaseImage2Request {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<Flatland2ReleaseImage2Request, D>
        for &Flatland2ReleaseImage2Request
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2ReleaseImage2Request>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Flatland2ReleaseImage2Request)
                    .write_unaligned((self as *const Flatland2ReleaseImage2Request).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ImageId, D>>
        fidl::encoding::Encode<Flatland2ReleaseImage2Request, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2ReleaseImage2Request>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for Flatland2ReleaseImage2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { image_id: fidl::new_empty!(ImageId, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for Flatland2ReleaseLayerRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Flatland2ReleaseLayerRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<Flatland2ReleaseLayerRequest, D> for &Flatland2ReleaseLayerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2ReleaseLayerRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Flatland2ReleaseLayerRequest)
                    .write_unaligned((self as *const Flatland2ReleaseLayerRequest).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<LayerId, D>>
        fidl::encoding::Encode<Flatland2ReleaseLayerRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2ReleaseLayerRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for Flatland2ReleaseLayerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { layer_id: fidl::new_empty!(LayerId, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for Flatland2ReleaseLayerStackRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Flatland2ReleaseLayerStackRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<Flatland2ReleaseLayerStackRequest, D>
        for &Flatland2ReleaseLayerStackRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2ReleaseLayerStackRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Flatland2ReleaseLayerStackRequest)
                    .write_unaligned((self as *const Flatland2ReleaseLayerStackRequest).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<LayerStackId, D>>
        fidl::encoding::Encode<Flatland2ReleaseLayerStackRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2ReleaseLayerStackRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for Flatland2ReleaseLayerStackRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { stack_id: fidl::new_empty!(LayerStackId, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for Flatland2ReleaseViewport2Request {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Flatland2ReleaseViewport2Request {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<Flatland2ReleaseViewport2Request, D>
        for &Flatland2ReleaseViewport2Request
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2ReleaseViewport2Request>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Flatland2ReleaseViewport2Request)
                    .write_unaligned((self as *const Flatland2ReleaseViewport2Request).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ViewportId, D>>
        fidl::encoding::Encode<Flatland2ReleaseViewport2Request, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2ReleaseViewport2Request>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for Flatland2ReleaseViewport2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { viewport_id: fidl::new_empty!(ViewportId, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for Flatland2ResetLayerRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Flatland2ResetLayerRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<Flatland2ResetLayerRequest, D> for &Flatland2ResetLayerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2ResetLayerRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut Flatland2ResetLayerRequest)
                    .write_unaligned((self as *const Flatland2ResetLayerRequest).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<LayerId, D>>
        fidl::encoding::Encode<Flatland2ResetLayerRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2ResetLayerRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for Flatland2ResetLayerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { layer_id: fidl::new_empty!(LayerId, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for Flatland2SetLayerPropertiesRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Flatland2SetLayerPropertiesRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<Flatland2SetLayerPropertiesRequest, D>
        for &Flatland2SetLayerPropertiesRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2SetLayerPropertiesRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Flatland2SetLayerPropertiesRequest, D>::encode(
                (
                    <LayerId as fidl::encoding::ValueTypeMarker>::borrow(&self.layer_id),
                    <LayerProperties as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<LayerId, D>,
        T1: fidl::encoding::Encode<LayerProperties, D>,
    > fidl::encoding::Encode<Flatland2SetLayerPropertiesRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2SetLayerPropertiesRequest>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for Flatland2SetLayerPropertiesRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                layer_id: fidl::new_empty!(LayerId, D),
                properties: fidl::new_empty!(LayerProperties, D),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for Flatland2SetStackLayersRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Flatland2SetStackLayersRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<Flatland2SetStackLayersRequest, D>
        for &Flatland2SetStackLayersRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2SetStackLayersRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Flatland2SetStackLayersRequest, D>::encode(
                (
                    <LayerStackId as fidl::encoding::ValueTypeMarker>::borrow(&self.stack_id),
                    <fidl::encoding::Vector<LayerId, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.layers),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<LayerStackId, D>,
        T1: fidl::encoding::Encode<fidl::encoding::Vector<LayerId, 32>, D>,
    > fidl::encoding::Encode<Flatland2SetStackLayersRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2SetStackLayersRequest>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for Flatland2SetStackLayersRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                stack_id: fidl::new_empty!(LayerStackId, D),
                layers: fidl::new_empty!(fidl::encoding::Vector<LayerId, 32>, D),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for Flatland2SetTransformContentRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Flatland2SetTransformContentRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<Flatland2SetTransformContentRequest, D>
        for &Flatland2SetTransformContentRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2SetTransformContentRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Flatland2SetTransformContentRequest, D>::encode(
                (
                    <TransformId as fidl::encoding::ValueTypeMarker>::borrow(&self.transform_id),
                    <fidl::encoding::OptionalUnion<TransformContent> as fidl::encoding::ValueTypeMarker>::borrow(&self.content),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<TransformId, D>,
        T1: fidl::encoding::Encode<fidl::encoding::OptionalUnion<TransformContent>, D>,
    > fidl::encoding::Encode<Flatland2SetTransformContentRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2SetTransformContentRequest>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for Flatland2SetTransformContentRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                transform_id: fidl::new_empty!(TransformId, D),
                content: fidl::new_empty!(fidl::encoding::OptionalUnion<TransformContent>, D),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for Flatland2SetViewportProperties2Request {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Flatland2SetViewportProperties2Request {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<Flatland2SetViewportProperties2Request, D>
        for &Flatland2SetViewportProperties2Request
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2SetViewportProperties2Request>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Flatland2SetViewportProperties2Request, D>::encode(
                (
                    <ViewportId as fidl::encoding::ValueTypeMarker>::borrow(&self.viewport_id),
                    <ViewportProperties as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.properties,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<ViewportId, D>,
        T1: fidl::encoding::Encode<ViewportProperties, D>,
    > fidl::encoding::Encode<Flatland2SetViewportProperties2Request, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Flatland2SetViewportProperties2Request>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for Flatland2SetViewportProperties2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                viewport_id: fidl::new_empty!(ViewportId, D),
                properties: fidl::new_empty!(ViewportProperties, D),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for FlatlandAddChildRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandAddChildRequest {
        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
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandAddChildRequest, D> for &FlatlandAddChildRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandAddChildRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FlatlandAddChildRequest)
                    .write_unaligned((self as *const FlatlandAddChildRequest).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<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<TransformId, D>,
        T1: fidl::encoding::Encode<TransformId, D>,
    > fidl::encoding::Encode<FlatlandAddChildRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandAddChildRequest>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandAddChildRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                parent_transform_id: fidl::new_empty!(TransformId, D),
                child_transform_id: fidl::new_empty!(TransformId, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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, 16);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FlatlandCreateTransformRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandCreateTransformRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandCreateTransformRequest, D>
        for &FlatlandCreateTransformRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandCreateTransformRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FlatlandCreateTransformRequest)
                    .write_unaligned((self as *const FlatlandCreateTransformRequest).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<TransformId, D>>
        fidl::encoding::Encode<FlatlandCreateTransformRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandCreateTransformRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandCreateTransformRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { transform_id: fidl::new_empty!(TransformId, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for FlatlandDisplaySetDevicePixelRatioRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandDisplaySetDevicePixelRatioRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandDisplaySetDevicePixelRatioRequest, D>
        for &FlatlandDisplaySetDevicePixelRatioRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandDisplaySetDevicePixelRatioRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandDisplaySetDevicePixelRatioRequest, D>::encode(
                (<fidl_fuchsia_math_common::VecF as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.device_pixel_ratio,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl_fuchsia_math_common::VecF, D>,
    > fidl::encoding::Encode<FlatlandDisplaySetDevicePixelRatioRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandDisplaySetDevicePixelRatioRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandDisplaySetDevicePixelRatioRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { device_pixel_ratio: fidl::new_empty!(fidl_fuchsia_math_common::VecF, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for FlatlandOnErrorRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandOnErrorRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandOnErrorRequest, D> for &FlatlandOnErrorRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandOnErrorRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandOnErrorRequest, D>::encode(
                (<FlatlandError as fidl::encoding::ValueTypeMarker>::borrow(&self.error),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<FlatlandError, D>>
        fidl::encoding::Encode<FlatlandOnErrorRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandOnErrorRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandOnErrorRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { error: fidl::new_empty!(FlatlandError, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for FlatlandOnFramePresentedRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandOnFramePresentedRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandOnFramePresentedRequest, D>
        for &FlatlandOnFramePresentedRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandOnFramePresentedRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandOnFramePresentedRequest, D>::encode(
                (
                    <fidl_fuchsia_scenic_scheduling_common::FramePresentedInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.frame_presented_info),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl_fuchsia_scenic_scheduling_common::FramePresentedInfo, D>,
    > fidl::encoding::Encode<FlatlandOnFramePresentedRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandOnFramePresentedRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandOnFramePresentedRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                frame_presented_info: fidl::new_empty!(
                    fidl_fuchsia_scenic_scheduling_common::FramePresentedInfo,
                    D
                ),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for FlatlandOnNextFrameBeginRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandOnNextFrameBeginRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandOnNextFrameBeginRequest, D>
        for &FlatlandOnNextFrameBeginRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandOnNextFrameBeginRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandOnNextFrameBeginRequest, D>::encode(
                (<OnNextFrameBeginValues as fidl::encoding::ValueTypeMarker>::borrow(&self.values),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<OnNextFrameBeginValues, D>,
    > fidl::encoding::Encode<FlatlandOnNextFrameBeginRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandOnNextFrameBeginRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandOnNextFrameBeginRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { values: fidl::new_empty!(OnNextFrameBeginValues, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for FlatlandReleaseFilledRectRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandReleaseFilledRectRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandReleaseFilledRectRequest, D>
        for &FlatlandReleaseFilledRectRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandReleaseFilledRectRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FlatlandReleaseFilledRectRequest)
                    .write_unaligned((self as *const FlatlandReleaseFilledRectRequest).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ContentId, D>>
        fidl::encoding::Encode<FlatlandReleaseFilledRectRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandReleaseFilledRectRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandReleaseFilledRectRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { rect_id: fidl::new_empty!(ContentId, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for FlatlandReleaseImageRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandReleaseImageRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandReleaseImageRequest, D> for &FlatlandReleaseImageRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandReleaseImageRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FlatlandReleaseImageRequest)
                    .write_unaligned((self as *const FlatlandReleaseImageRequest).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ContentId, D>>
        fidl::encoding::Encode<FlatlandReleaseImageRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandReleaseImageRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandReleaseImageRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { image_id: fidl::new_empty!(ContentId, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for FlatlandReleaseTransformRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandReleaseTransformRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandReleaseTransformRequest, D>
        for &FlatlandReleaseTransformRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandReleaseTransformRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FlatlandReleaseTransformRequest)
                    .write_unaligned((self as *const FlatlandReleaseTransformRequest).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<TransformId, D>>
        fidl::encoding::Encode<FlatlandReleaseTransformRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandReleaseTransformRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandReleaseTransformRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { transform_id: fidl::new_empty!(TransformId, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for FlatlandReleaseViewportRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandReleaseViewportRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandReleaseViewportRequest, D>
        for &FlatlandReleaseViewportRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandReleaseViewportRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FlatlandReleaseViewportRequest)
                    .write_unaligned((self as *const FlatlandReleaseViewportRequest).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ContentId, D>>
        fidl::encoding::Encode<FlatlandReleaseViewportRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandReleaseViewportRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandReleaseViewportRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { viewport_id: fidl::new_empty!(ContentId, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for FlatlandRemoveChildRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandRemoveChildRequest {
        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
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandRemoveChildRequest, D> for &FlatlandRemoveChildRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandRemoveChildRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FlatlandRemoveChildRequest)
                    .write_unaligned((self as *const FlatlandRemoveChildRequest).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<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<TransformId, D>,
        T1: fidl::encoding::Encode<TransformId, D>,
    > fidl::encoding::Encode<FlatlandRemoveChildRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandRemoveChildRequest>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandRemoveChildRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                parent_transform_id: fidl::new_empty!(TransformId, D),
                child_transform_id: fidl::new_empty!(TransformId, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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, 16);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FlatlandReplaceChildrenRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandReplaceChildrenRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandReplaceChildrenRequest, D>
        for &FlatlandReplaceChildrenRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandReplaceChildrenRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandReplaceChildrenRequest, D>::encode(
                (
                    <TransformId as fidl::encoding::ValueTypeMarker>::borrow(&self.parent_transform_id),
                    <fidl::encoding::Vector<TransformId, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.new_child_transform_ids),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<TransformId, D>,
        T1: fidl::encoding::Encode<fidl::encoding::Vector<TransformId, 64>, D>,
    > fidl::encoding::Encode<FlatlandReplaceChildrenRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandReplaceChildrenRequest>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandReplaceChildrenRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                parent_transform_id: fidl::new_empty!(TransformId, D),
                new_child_transform_ids: fidl::new_empty!(fidl::encoding::Vector<TransformId, 64>, D),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for FlatlandSetClipBoundaryRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetClipBoundaryRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetClipBoundaryRequest, D>
        for &FlatlandSetClipBoundaryRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetClipBoundaryRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandSetClipBoundaryRequest, D>::encode(
                (
                    <TransformId as fidl::encoding::ValueTypeMarker>::borrow(&self.transform_id),
                    <fidl::encoding::Boxed<fidl_fuchsia_math_common::Rect> as fidl::encoding::ValueTypeMarker>::borrow(&self.rect),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<TransformId, D>,
        T1: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_math_common::Rect>, D>,
    > fidl::encoding::Encode<FlatlandSetClipBoundaryRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetClipBoundaryRequest>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetClipBoundaryRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                transform_id: fidl::new_empty!(TransformId, D),
                rect: fidl::new_empty!(fidl::encoding::Boxed<fidl_fuchsia_math_common::Rect>, D),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for FlatlandSetContentRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetContentRequest {
        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
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetContentRequest, D> for &FlatlandSetContentRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetContentRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FlatlandSetContentRequest)
                    .write_unaligned((self as *const FlatlandSetContentRequest).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<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<TransformId, D>,
        T1: fidl::encoding::Encode<ContentId, D>,
    > fidl::encoding::Encode<FlatlandSetContentRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetContentRequest>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetContentRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                transform_id: fidl::new_empty!(TransformId, D),
                content_id: fidl::new_empty!(ContentId, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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, 16);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FlatlandSetDebugNameRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetDebugNameRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetDebugNameRequest, D> for &FlatlandSetDebugNameRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetDebugNameRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandSetDebugNameRequest, D>::encode(
                (<fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.name,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::BoundedString<64>, D>,
    > fidl::encoding::Encode<FlatlandSetDebugNameRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetDebugNameRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetDebugNameRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { name: fidl::new_empty!(fidl::encoding::BoundedString<64>, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for FlatlandSetHitRegionsRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetHitRegionsRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetHitRegionsRequest, D> for &FlatlandSetHitRegionsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetHitRegionsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandSetHitRegionsRequest, D>::encode(
                (
                    <TransformId as fidl::encoding::ValueTypeMarker>::borrow(&self.transform_id),
                    <fidl::encoding::Vector<HitRegion, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.regions),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<TransformId, D>,
        T1: fidl::encoding::Encode<fidl::encoding::Vector<HitRegion, 64>, D>,
    > fidl::encoding::Encode<FlatlandSetHitRegionsRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetHitRegionsRequest>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetHitRegionsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                transform_id: fidl::new_empty!(TransformId, D),
                regions: fidl::new_empty!(fidl::encoding::Vector<HitRegion, 64>, D),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for FlatlandSetImageBlendModeRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetImageBlendModeRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetImageBlendModeRequest, D>
        for &FlatlandSetImageBlendModeRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetImageBlendModeRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandSetImageBlendModeRequest, D>::encode(
                (
                    <ContentId as fidl::encoding::ValueTypeMarker>::borrow(&self.image_id),
                    <BlendMode2 as fidl::encoding::ValueTypeMarker>::borrow(&self.blend_mode),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<ContentId, D>,
        T1: fidl::encoding::Encode<BlendMode2, D>,
    > fidl::encoding::Encode<FlatlandSetImageBlendModeRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetImageBlendModeRequest>(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);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetImageBlendModeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                image_id: fidl::new_empty!(ContentId, D),
                blend_mode: fidl::new_empty!(BlendMode2, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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,
                });
            }
            fidl::decode!(ContentId, D, &mut self.image_id, decoder, offset + 0, _depth)?;
            fidl::decode!(BlendMode2, D, &mut self.blend_mode, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FlatlandSetImageBlendingFunctionRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetImageBlendingFunctionRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetImageBlendingFunctionRequest, D>
        for &FlatlandSetImageBlendingFunctionRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetImageBlendingFunctionRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandSetImageBlendingFunctionRequest, D>::encode(
                (
                    <ContentId as fidl::encoding::ValueTypeMarker>::borrow(&self.image_id),
                    <BlendMode as fidl::encoding::ValueTypeMarker>::borrow(&self.blend_mode),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<ContentId, D>,
        T1: fidl::encoding::Encode<BlendMode, D>,
    > fidl::encoding::Encode<FlatlandSetImageBlendingFunctionRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetImageBlendingFunctionRequest>(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);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetImageBlendingFunctionRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                image_id: fidl::new_empty!(ContentId, D),
                blend_mode: fidl::new_empty!(BlendMode, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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,
                });
            }
            fidl::decode!(ContentId, D, &mut self.image_id, decoder, offset + 0, _depth)?;
            fidl::decode!(BlendMode, D, &mut self.blend_mode, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FlatlandSetImageDestinationSizeRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetImageDestinationSizeRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetImageDestinationSizeRequest, D>
        for &FlatlandSetImageDestinationSizeRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetImageDestinationSizeRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandSetImageDestinationSizeRequest, D>::encode(
                (
                    <ContentId as fidl::encoding::ValueTypeMarker>::borrow(&self.image_id),
                    <fidl_fuchsia_math_common::SizeU as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.size,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<ContentId, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_math_common::SizeU, D>,
    > fidl::encoding::Encode<FlatlandSetImageDestinationSizeRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetImageDestinationSizeRequest>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetImageDestinationSizeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                image_id: fidl::new_empty!(ContentId, D),
                size: fidl::new_empty!(fidl_fuchsia_math_common::SizeU, D),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for FlatlandSetImageFlipRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetImageFlipRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetImageFlipRequest, D> for &FlatlandSetImageFlipRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetImageFlipRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandSetImageFlipRequest, D>::encode(
                (
                    <ContentId as fidl::encoding::ValueTypeMarker>::borrow(&self.image_id),
                    <ImageFlip as fidl::encoding::ValueTypeMarker>::borrow(&self.flip),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<ContentId, D>,
        T1: fidl::encoding::Encode<ImageFlip, D>,
    > fidl::encoding::Encode<FlatlandSetImageFlipRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetImageFlipRequest>(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);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetImageFlipRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { image_id: fidl::new_empty!(ContentId, D), flip: fidl::new_empty!(ImageFlip, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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,
                });
            }
            fidl::decode!(ContentId, D, &mut self.image_id, decoder, offset + 0, _depth)?;
            fidl::decode!(ImageFlip, D, &mut self.flip, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FlatlandSetImageOpacityRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetImageOpacityRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetImageOpacityRequest, D>
        for &FlatlandSetImageOpacityRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetImageOpacityRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandSetImageOpacityRequest, D>::encode(
                (
                    <ContentId as fidl::encoding::ValueTypeMarker>::borrow(&self.image_id),
                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.val),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<ContentId, D>,
        T1: fidl::encoding::Encode<f32, D>,
    > fidl::encoding::Encode<FlatlandSetImageOpacityRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetImageOpacityRequest>(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);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetImageOpacityRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { image_id: fidl::new_empty!(ContentId, D), val: fidl::new_empty!(f32, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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,
                });
            }
            fidl::decode!(ContentId, D, &mut self.image_id, decoder, offset + 0, _depth)?;
            fidl::decode!(f32, D, &mut self.val, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FlatlandSetImageSampleRegionRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetImageSampleRegionRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetImageSampleRegionRequest, D>
        for &FlatlandSetImageSampleRegionRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetImageSampleRegionRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandSetImageSampleRegionRequest, D>::encode(
                (
                    <ContentId as fidl::encoding::ValueTypeMarker>::borrow(&self.image_id),
                    <fidl_fuchsia_math_common::RectF as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.rect,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<ContentId, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_math_common::RectF, D>,
    > fidl::encoding::Encode<FlatlandSetImageSampleRegionRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetImageSampleRegionRequest>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetImageSampleRegionRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                image_id: fidl::new_empty!(ContentId, D),
                rect: fidl::new_empty!(fidl_fuchsia_math_common::RectF, D),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for FlatlandSetInfiniteHitRegionRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetInfiniteHitRegionRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetInfiniteHitRegionRequest, D>
        for &FlatlandSetInfiniteHitRegionRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetInfiniteHitRegionRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandSetInfiniteHitRegionRequest, D>::encode(
                (
                    <TransformId as fidl::encoding::ValueTypeMarker>::borrow(&self.transform_id),
                    <HitTestInteraction as fidl::encoding::ValueTypeMarker>::borrow(&self.hit_test),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<TransformId, D>,
        T1: fidl::encoding::Encode<HitTestInteraction, D>,
    > fidl::encoding::Encode<FlatlandSetInfiniteHitRegionRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetInfiniteHitRegionRequest>(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);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetInfiniteHitRegionRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                transform_id: fidl::new_empty!(TransformId, D),
                hit_test: fidl::new_empty!(HitTestInteraction, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 = 0xffffffffffffff00u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(TransformId, D, &mut self.transform_id, decoder, offset + 0, _depth)?;
            fidl::decode!(HitTestInteraction, D, &mut self.hit_test, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FlatlandSetOpacityRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetOpacityRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetOpacityRequest, D> for &FlatlandSetOpacityRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetOpacityRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandSetOpacityRequest, D>::encode(
                (
                    <TransformId as fidl::encoding::ValueTypeMarker>::borrow(&self.transform_id),
                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<TransformId, D>,
        T1: fidl::encoding::Encode<f32, D>,
    > fidl::encoding::Encode<FlatlandSetOpacityRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetOpacityRequest>(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);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetOpacityRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { transform_id: fidl::new_empty!(TransformId, D), value: fidl::new_empty!(f32, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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,
                });
            }
            fidl::decode!(TransformId, D, &mut self.transform_id, decoder, offset + 0, _depth)?;
            fidl::decode!(f32, D, &mut self.value, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FlatlandSetOrientationRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetOrientationRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetOrientationRequest, D>
        for &FlatlandSetOrientationRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetOrientationRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandSetOrientationRequest, D>::encode(
                (
                    <TransformId as fidl::encoding::ValueTypeMarker>::borrow(&self.transform_id),
                    <Orientation as fidl::encoding::ValueTypeMarker>::borrow(&self.orientation),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<TransformId, D>,
        T1: fidl::encoding::Encode<Orientation, D>,
    > fidl::encoding::Encode<FlatlandSetOrientationRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetOrientationRequest>(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);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetOrientationRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                transform_id: fidl::new_empty!(TransformId, D),
                orientation: fidl::new_empty!(Orientation, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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,
                });
            }
            fidl::decode!(TransformId, D, &mut self.transform_id, decoder, offset + 0, _depth)?;
            fidl::decode!(Orientation, D, &mut self.orientation, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FlatlandSetRootTransformRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetRootTransformRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetRootTransformRequest, D>
        for &FlatlandSetRootTransformRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetRootTransformRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FlatlandSetRootTransformRequest)
                    .write_unaligned((self as *const FlatlandSetRootTransformRequest).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<TransformId, D>>
        fidl::encoding::Encode<FlatlandSetRootTransformRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetRootTransformRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetRootTransformRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { transform_id: fidl::new_empty!(TransformId, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for FlatlandSetScaleRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetScaleRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetScaleRequest, D> for &FlatlandSetScaleRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetScaleRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandSetScaleRequest, D>::encode(
                (
                    <TransformId as fidl::encoding::ValueTypeMarker>::borrow(&self.transform_id),
                    <fidl_fuchsia_math_common::VecF as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.scale,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<TransformId, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_math_common::VecF, D>,
    > fidl::encoding::Encode<FlatlandSetScaleRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetScaleRequest>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetScaleRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                transform_id: fidl::new_empty!(TransformId, D),
                scale: fidl::new_empty!(fidl_fuchsia_math_common::VecF, D),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for FlatlandSetTranslationRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetTranslationRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetTranslationRequest, D>
        for &FlatlandSetTranslationRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetTranslationRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandSetTranslationRequest, D>::encode(
                (
                    <TransformId as fidl::encoding::ValueTypeMarker>::borrow(&self.transform_id),
                    <fidl_fuchsia_math_common::Vec_ as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.translation,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<TransformId, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_math_common::Vec_, D>,
    > fidl::encoding::Encode<FlatlandSetTranslationRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetTranslationRequest>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetTranslationRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                transform_id: fidl::new_empty!(TransformId, D),
                translation: fidl::new_empty!(fidl_fuchsia_math_common::Vec_, D),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for FlatlandSetViewportPropertiesRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandSetViewportPropertiesRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FlatlandSetViewportPropertiesRequest, D>
        for &FlatlandSetViewportPropertiesRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetViewportPropertiesRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FlatlandSetViewportPropertiesRequest, D>::encode(
                (
                    <ContentId as fidl::encoding::ValueTypeMarker>::borrow(&self.viewport_id),
                    <ViewportProperties as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.properties,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<ContentId, D>,
        T1: fidl::encoding::Encode<ViewportProperties, D>,
    > fidl::encoding::Encode<FlatlandSetViewportPropertiesRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandSetViewportPropertiesRequest>(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)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FlatlandSetViewportPropertiesRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                viewport_id: fidl::new_empty!(ContentId, D),
                properties: fidl::new_empty!(ViewportProperties, D),
            }
        }

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

    impl fidl::encoding::ValueTypeMarker for HitRegion {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HitRegion, D>
        for &HitRegion
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<HitRegion>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<HitRegion, D>::encode(
                (
                    <fidl_fuchsia_math_common::RectF as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.region,
                    ),
                    <HitTestInteraction as fidl::encoding::ValueTypeMarker>::borrow(&self.hit_test),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl_fuchsia_math_common::RectF, D>,
        T1: fidl::encoding::Encode<HitTestInteraction, D>,
    > fidl::encoding::Encode<HitRegion, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<HitRegion>(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(16);
                (ptr as *mut u32).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HitRegion {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                region: fidl::new_empty!(fidl_fuchsia_math_common::RectF, D),
                hit_test: fidl::new_empty!(HitTestInteraction, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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(16) };
            let padval = unsafe { (ptr as *const u32).read_unaligned() };
            let mask = 0xffffff00u32;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl_fuchsia_math_common::RectF,
                D,
                &mut self.region,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(HitTestInteraction, D, &mut self.hit_test, decoder, offset + 16, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ImageId {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ImageId {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ImageId, D> for &ImageId {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageId>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut ImageId).write_unaligned((self as *const ImageId).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<ImageId, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageId>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ImageId {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { value: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for LayerId {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LayerId {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LayerId, D> for &LayerId {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LayerId>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut LayerId).write_unaligned((self as *const LayerId).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<LayerId, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LayerId>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LayerId {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { value: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for LayerStackId {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LayerStackId {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LayerStackId, D>
        for &LayerStackId
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LayerStackId>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut LayerStackId)
                    .write_unaligned((self as *const LayerStackId).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<LayerStackId, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LayerStackId>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LayerStackId {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { value: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for ParentViewportWatcherGetLayoutResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ParentViewportWatcherGetLayoutResponse {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ParentViewportWatcherGetLayoutResponse, D>
        for &ParentViewportWatcherGetLayoutResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ParentViewportWatcherGetLayoutResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ParentViewportWatcherGetLayoutResponse, D>::encode(
                (<LayoutInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<LayoutInfo, D>>
        fidl::encoding::Encode<ParentViewportWatcherGetLayoutResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ParentViewportWatcherGetLayoutResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ParentViewportWatcherGetLayoutResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { info: fidl::new_empty!(LayoutInfo, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for ParentViewportWatcherGetStatusResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ParentViewportWatcherGetStatusResponse {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ParentViewportWatcherGetStatusResponse, D>
        for &ParentViewportWatcherGetStatusResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ParentViewportWatcherGetStatusResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ParentViewportWatcherGetStatusResponse, D>::encode(
                (<ParentViewportStatus as fidl::encoding::ValueTypeMarker>::borrow(&self.status),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<ParentViewportStatus, D>,
    > fidl::encoding::Encode<ParentViewportWatcherGetStatusResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ParentViewportWatcherGetStatusResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ParentViewportWatcherGetStatusResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { status: fidl::new_empty!(ParentViewportStatus, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for ScreenCaptureReleaseFrameRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ScreenCaptureReleaseFrameRequest, D>
        for &ScreenCaptureReleaseFrameRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ScreenCaptureReleaseFrameRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut ScreenCaptureReleaseFrameRequest)
                    .write_unaligned((self as *const ScreenCaptureReleaseFrameRequest).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
        fidl::encoding::Encode<ScreenCaptureReleaseFrameRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ScreenCaptureReleaseFrameRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ScreenCaptureReleaseFrameRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { buffer_id: fidl::new_empty!(u32, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for TransformId {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TransformId {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TransformId, D>
        for &TransformId
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TransformId>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut TransformId).write_unaligned((self as *const TransformId).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<TransformId, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TransformId>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TransformId {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { value: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for TrustedFlatlandReleaseImageImmediately2Request {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TrustedFlatlandReleaseImageImmediately2Request {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<TrustedFlatlandReleaseImageImmediately2Request, D>
        for &TrustedFlatlandReleaseImageImmediately2Request
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TrustedFlatlandReleaseImageImmediately2Request>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut TrustedFlatlandReleaseImageImmediately2Request).write_unaligned(
                    (self as *const TrustedFlatlandReleaseImageImmediately2Request).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ImageId, D>>
        fidl::encoding::Encode<TrustedFlatlandReleaseImageImmediately2Request, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TrustedFlatlandReleaseImageImmediately2Request>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for TrustedFlatlandReleaseImageImmediately2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { image_id: fidl::new_empty!(ImageId, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for TrustedFlatlandReleaseImageImmediatelyRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TrustedFlatlandReleaseImageImmediatelyRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<TrustedFlatlandReleaseImageImmediatelyRequest, D>
        for &TrustedFlatlandReleaseImageImmediatelyRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TrustedFlatlandReleaseImageImmediatelyRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut TrustedFlatlandReleaseImageImmediatelyRequest).write_unaligned(
                    (self as *const TrustedFlatlandReleaseImageImmediatelyRequest).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ContentId, D>>
        fidl::encoding::Encode<TrustedFlatlandReleaseImageImmediatelyRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TrustedFlatlandReleaseImageImmediatelyRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for TrustedFlatlandReleaseImageImmediatelyRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { image_id: fidl::new_empty!(ContentId, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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::ValueTypeMarker for ViewportId {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ViewportId {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ViewportId, D>
        for &ViewportId
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ViewportId>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut ViewportId).write_unaligned((self as *const ViewportId).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<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<ViewportId, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ViewportId>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ViewportId {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { value: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 FlatlandConfig {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.use_flatland2 {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for FlatlandConfig {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FlatlandConfig {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FlatlandConfig, D>
        for &FlatlandConfig
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FlatlandConfig>(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, D>(
                self.use_flatland2.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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.use_flatland2.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, 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 ImageProperties {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.size {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for ImageProperties {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ImageProperties {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ImageProperties, D>
        for &ImageProperties
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageProperties>(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_fuchsia_math_common::SizeU, D>(
                self.size.as_ref().map(
                    <fidl_fuchsia_math_common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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_fuchsia_math_common::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_common::SizeU, D));
                fidl::decode!(
                    fidl_fuchsia_math_common::SizeU,
                    D,
                    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 LayerProperties {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.composition_mode {
                return 9;
            }
            if let Some(_) = self.hint_visible_rects {
                return 8;
            }
            if let Some(_) = self.hint_damage_rects {
                return 7;
            }
            if let Some(_) = self.transform {
                return 6;
            }
            if let Some(_) = self.sample_rect {
                return 5;
            }
            if let Some(_) = self.color {
                return 4;
            }
            if let Some(_) = self.blend_mode {
                return 3;
            }
            if let Some(_) = self.opacity {
                return 2;
            }
            if let Some(_) = self.display_rect {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for LayerProperties {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LayerProperties {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LayerProperties, D>
        for &LayerProperties
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LayerProperties>(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_fuchsia_math_common::RectU, D>(
                self.display_rect.as_ref().map(
                    <fidl_fuchsia_math_common::RectU 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::<f32, D>(
                self.opacity.as_ref().map(<f32 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::<BlendMode2, D>(
                self.blend_mode
                    .as_ref()
                    .map(<BlendMode2 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::<ColorRgba, D>(
                self.color.as_ref().map(<ColorRgba 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_fuchsia_math_common::RectF, D>(
                self.sample_rect.as_ref().map(
                    <fidl_fuchsia_math_common::RectF as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<FlipThenRotate, D>(
                self.transform
                    .as_ref()
                    .map(<FlipThenRotate 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::UnboundedVector<fidl_fuchsia_math_common::RectU>, D>(
            self.hint_damage_rects.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_math_common::RectU> as fidl::encoding::ValueTypeMarker>::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::UnboundedVector<fidl_fuchsia_math_common::RectU>, D>(
            self.hint_visible_rects.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_math_common::RectU> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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_fuchsia_math_common::RectU 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
                    .display_rect
                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math_common::RectU, D));
                fidl::decode!(
                    fidl_fuchsia_math_common::RectU,
                    D,
                    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 =
                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.opacity.get_or_insert_with(|| fidl::new_empty!(f32, D));
                fidl::decode!(f32, D, 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 =
                    <BlendMode2 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.blend_mode.get_or_insert_with(|| fidl::new_empty!(BlendMode2, D));
                fidl::decode!(BlendMode2, D, 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 =
                    <ColorRgba 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.color.get_or_insert_with(|| fidl::new_empty!(ColorRgba, D));
                fidl::decode!(ColorRgba, D, 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_fuchsia_math_common::RectF 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
                    .sample_rect
                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math_common::RectF, D));
                fidl::decode!(
                    fidl_fuchsia_math_common::RectF,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <FlipThenRotate 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.transform.get_or_insert_with(|| fidl::new_empty!(FlipThenRotate, D));
                fidl::decode!(FlipThenRotate, D, 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::UnboundedVector<
                    fidl_fuchsia_math_common::RectU,
                > 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.hint_damage_rects.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::UnboundedVector<fidl_fuchsia_math_common::RectU>,
                        D
                    )
                });
                fidl::decode!(
                    fidl::encoding::UnboundedVector<fidl_fuchsia_math_common::RectU>,
                    D,
                    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::UnboundedVector<
                    fidl_fuchsia_math_common::RectU,
                > 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.hint_visible_rects.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::UnboundedVector<fidl_fuchsia_math_common::RectU>,
                        D
                    )
                });
                fidl::decode!(
                    fidl::encoding::UnboundedVector<fidl_fuchsia_math_common::RectU>,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <CompositionMode 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
                    .composition_mode
                    .get_or_insert_with(|| fidl::new_empty!(CompositionMode, D));
                fidl::decode!(CompositionMode, D, 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 LayoutInfo {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.inset {
                return 4;
            }
            if let Some(_) = self.device_pixel_ratio {
                return 3;
            }
            if let Some(_) = self.logical_size {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for LayoutInfo {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LayoutInfo {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LayoutInfo, D>
        for &LayoutInfo
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LayoutInfo>(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_fuchsia_math_common::SizeU, D>(
                self.logical_size.as_ref().map(
                    <fidl_fuchsia_math_common::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::<fidl_fuchsia_math_common::VecF, D>(
                self.device_pixel_ratio.as_ref().map(
                    <fidl_fuchsia_math_common::VecF 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::<fidl_fuchsia_math_common::Inset, D>(
                self.inset.as_ref().map(
                    <fidl_fuchsia_math_common::Inset as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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_fuchsia_math_common::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
                    .logical_size
                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math_common::SizeU, D));
                fidl::decode!(
                    fidl_fuchsia_math_common::SizeU,
                    D,
                    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_fuchsia_math_common::VecF as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .device_pixel_ratio
                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math_common::VecF, D));
                fidl::decode!(
                    fidl_fuchsia_math_common::VecF,
                    D,
                    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_fuchsia_math_common::Inset 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
                    .inset
                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math_common::Inset, D));
                fidl::decode!(
                    fidl_fuchsia_math_common::Inset,
                    D,
                    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 OnNextFrameBeginValues {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.future_presentation_infos {
                return 2;
            }
            if let Some(_) = self.additional_present_credits {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for OnNextFrameBeginValues {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for OnNextFrameBeginValues {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<OnNextFrameBeginValues, D> for &OnNextFrameBeginValues
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<OnNextFrameBeginValues>(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, D>(
                self.additional_present_credits
                    .as_ref()
                    .map(<u32 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_fuchsia_scenic_scheduling_common::PresentationInfo, 8>,
                D,
            >(
                self.future_presentation_infos.as_ref().map(
                    <fidl::encoding::Vector<
                        fidl_fuchsia_scenic_scheduling_common::PresentationInfo,
                        8,
                    > as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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.additional_present_credits.get_or_insert_with(|| fidl::new_empty!(u32, D));
                fidl::decode!(u32, D, 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_fuchsia_scenic_scheduling_common::PresentationInfo,
                    8,
                > 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.future_presentation_infos.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_scenic_scheduling_common::PresentationInfo, 8>, D));
                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_scenic_scheduling_common::PresentationInfo, 8>, D, 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 ViewportProperties {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.inset {
                return 2;
            }
            if let Some(_) = self.logical_size {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for ViewportProperties {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ViewportProperties {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ViewportProperties, D>
        for &ViewportProperties
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ViewportProperties>(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_fuchsia_math_common::SizeU, D>(
                self.logical_size.as_ref().map(
                    <fidl_fuchsia_math_common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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_fuchsia_math_common::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
                    .logical_size
                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math_common::SizeU, D));
                fidl::decode!(
                    fidl_fuchsia_math_common::SizeU,
                    D,
                    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_common::Inset 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
                    .inset
                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math_common::Inset, D));
                fidl::decode!(
                    fidl_fuchsia_math_common::Inset,
                    D,
                    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 fidl::encoding::ValueTypeMarker for TransformContent {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TransformContent {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TransformContent, D>
        for &TransformContent
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TransformContent>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                TransformContent::LayerStack(ref val) => {
                    fidl::encoding::encode_in_envelope::<LayerStackId, D>(
                        <LayerStackId as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                TransformContent::Viewport(ref val) => {
                    fidl::encoding::encode_in_envelope::<ViewportId, D>(
                        <ViewportId as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TransformContent {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::LayerStack(fidl::new_empty!(LayerStackId, D))
        }

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

            let member_inline_size = match ordinal {
                1 => <LayerStackId as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <ViewportId as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                _ => return Err(fidl::Error::UnknownUnionTag),
            };

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