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

// fidl_experiment = transitional_allow_list

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

use {
    bitflags::bitflags,
    fidl::{
        client::QueryResponseFut,
        endpoints::{ControlHandle as _, Responder as _},
    },
    fuchsia_zircon_status as zx_status,
    futures::future::{self, MaybeDone, TryFutureExt},
};

#[cfg(target_os = "fuchsia")]
use fuchsia_zircon as zx;

/// Maximum length for a resource label.
pub const LABEL_MAX_LENGTH: u32 = 32;

/// Reports metrics information.
/// This event type is only reported for node resources.
pub const METRICS_EVENT_MASK: u32 = 1;

pub const SIZE_CHANGE_HINT_EVENT_MASK: u32 = 2;

/// Describes how nodes interact with hit testings.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum HitTestBehavior {
    /// Apply hit testing to the node's content, its parts, and its children.
    KDefault = 0,
    /// Suppress hit testing of the node and everything it contains.
    KSuppress = 1,
}

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

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

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// Describes an exported resource that is to be imported by an
/// ImportResourceCmd.
///
/// NOTE: Currently just an enum of importable resource types, but may later be
/// expanded to express concepts like "meshes with a particular vertex format".
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ImportSpec {
    Node = 0,
}

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

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

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// Set a mesh's indices and vertices.
///
/// `mesh_id` refs the Mesh to be updated.
/// `index_buffer_id` refs a Buffer that contains the mesh indices.
/// `index_format` defines how the index buffer data is to be interpreted.
/// `index_offset` number of bytes from the start of the index Buffer.
/// `index_count` number of indices.
/// `vertex_buffer_id` refs a Buffer that contains the mesh vertices.
/// `vertex_format` defines how the vertex buffer data is to be interpreted.
/// `vertex_offset` number of bytes from the start of the vertex Buffer.
/// `vertex_count` number of vertices.
/// `bounding_box` must contain all vertices within the specified range.
///
/// The MeshVertexFormat defines which per-vertex attributes are provided by the
/// mesh, and the size of each attribute (and therefore the size of each vertex).
/// The attributes are ordered within the vertex in the same order that they
/// appear within the MeshVertexFormat struct.  For example, if the values are
/// kVector3, kNone and kVector2, then:
///   - each vertex has a position and UV-coordinates, but no surface normal.
///   - the 3D position occupies bytes 0-11 (3 dimensions * 4 bytes per float32).
///   - the UV coords occupy bytes 12-19, since no surface normal is provided.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum MeshIndexFormat {
    KUint16 = 1,
    KUint32 = 2,
}

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

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

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum RenderFrequency {
    WhenRequested = 0,
    Continuously = 1,
}

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

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

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// Represents the shadow algorithm that the `Renderer` should use when lighting
/// the scene.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ShadowTechnique {
    /// No shadows.
    Unshadowed = 0,
    /// Default.  Screen-space, depth-buffer based shadows; SSDO-ish.
    ScreenSpace = 1,
    /// Basic shadow map.
    ShadowMap = 2,
    /// Moment shadow map (see http:///momentsingraphics.de).
    MomentShadowMap = 3,
    /// Stencil shadow volume.
    StencilShadowVolume = 4,
}

impl ShadowTechnique {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Unshadowed),
            1 => Some(Self::ScreenSpace),
            2 => Some(Self::ShadowMap),
            3 => Some(Self::MomentShadowMap),
            4 => Some(Self::StencilShadowVolume),
            _ => None,
        }
    }

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

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ValueType {
    KNone = 0,
    KVector1 = 1,
    KVector2 = 2,
    KVector3 = 3,
    KVector4 = 4,
    KMatrix4 = 5,
    KColorRgb = 6,
    KColorRgba = 7,
    KQuaternion = 8,
    KFactoredTransform = 9,
}

impl ValueType {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::KNone),
            1 => Some(Self::KVector1),
            2 => Some(Self::KVector2),
            3 => Some(Self::KVector3),
            4 => Some(Self::KVector4),
            5 => Some(Self::KMatrix4),
            6 => Some(Self::KColorRgb),
            7 => Some(Self::KColorRgba),
            8 => Some(Self::KQuaternion),
            9 => Some(Self::KFactoredTransform),
            _ => None,
        }
    }

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

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// Add a node as a child to another node.
///
/// Constraints:
/// - `id` refs a Node with the has_children characteristic.
/// - `child_id` refs any Node.
///
/// Discussion:
/// The child node is first removed from its existing parent, as if DetachCmd
/// was applied first.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct AddChildCmd {
    pub node_id: u32,
    pub child_id: u32,
}

impl fidl::Persistable for AddChildCmd {}

/// Add a layer to a layer stack.
/// Constraints:
/// - `layer_stack_id` refs a `LayerStack`.
/// - `layer_id` refs a `Layer`.
/// - The layer must not already belong to a different stack; it must first be
///   detached.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct AddLayerCmd {
    pub layer_stack_id: u32,
    pub layer_id: u32,
}

impl fidl::Persistable for AddLayerCmd {}

/// Adds the light specified by `light_id` specified by `light_id` to the scene
/// identified by `scene_id`.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct AddLightCmd {
    pub scene_id: u32,
    pub light_id: u32,
}

impl fidl::Persistable for AddLightCmd {}

/// Add a node as a part of another node.  The implications of being a part
/// rather than a child differ based on the type of the part.  However, one
/// implication is constant: removing all of a node's children (e.g. via
/// DetachChildrenCmd) does not affect its parts.  This is similar to the
/// "shadow DOM" in a web browser: the controls of a <video> element are
/// implemented as using the shadow DOM, and do no show up amongst the children
/// of that element.
///
/// Constraints:
/// - `id` refs a Node with the has_parts characteristic.
/// - `part_id` refs any Node.
///
/// Discussion:
/// The part node is first removed from its existing parent, as if DetachCmd
/// was applied first.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct AddPartCmd {
    pub node_id: u32,
    pub part_id: u32,
}

impl fidl::Persistable for AddPartCmd {}

/// An AmbientLight is a Light that is is assumed to be everywhere in the scene,
/// in all directions.
///
/// Supported commands:
/// - SetLightColor
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct AmbientLightArgs {
    pub dummy: u32,
}

impl fidl::Persistable for AmbientLightArgs {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct BindMeshBuffersCmd {
    pub mesh_id: u32,
    pub index_buffer_id: u32,
    pub index_format: MeshIndexFormat,
    pub index_offset: u64,
    pub index_count: u32,
    pub vertex_buffer_id: u32,
    pub vertex_format: MeshVertexFormat,
    pub vertex_offset: u64,
    pub vertex_count: u32,
    pub bounding_box: BoundingBox,
}

impl fidl::Persistable for BindMeshBuffersCmd {}

/// Represents an axis-aligned bounding box.
///
/// If any of the dimensions has a negative extent (e.g. max.x < min.x) then the
/// bounding box is treated as empty. It is valid for a client to define an
/// empty bounding box.
///
/// An "empty bounding box" is one that does not admit a point inhabitant.
/// Note that a zero-volume, zero-area bounding box (e.g., a point like
/// (0,0,0)-(0,0,0), or a line like (0,0,0)-(1,0,0)) is thus not empty.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct BoundingBox {
    pub min: Vec3,
    pub max: Vec3,
}

impl fidl::Persistable for BoundingBox {}

/// A buffer mapped to a range of `Memory`.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct BufferArgs {
    pub memory_id: u32,
    pub memory_offset: u32,
    pub num_bytes: u32,
}

impl fidl::Persistable for BufferArgs {}

/// A Camera is used to render a Scene from a particular viewpoint.  This is
/// achieved by setting a Renderer to use the camera.
///
/// The following commands may be applied to a Camera:
/// - SetCameraTransform
/// - SetCameraProjection
/// - SetCameraPoseBuffer
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CameraArgs {
    /// The scene that the camera is viewing.
    pub scene_id: u32,
}

impl fidl::Persistable for CameraArgs {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct CircleArgs {
    pub radius: Value,
}

impl fidl::Persistable for CircleArgs {}

/// Characteristics:
/// - has_parent
/// - is_clip
/// - has_parts
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ClipNodeArgs {
    pub unused: u32,
}

impl fidl::Persistable for ClipNodeArgs {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct ColorRgb {
    pub red: f32,
    pub green: f32,
    pub blue: f32,
}

impl fidl::Persistable for ColorRgb {}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a ColorRgb, and `value` is ignored.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct ColorRgbValue {
    pub value: ColorRgb,
    pub variable_id: u32,
}

impl fidl::Persistable for ColorRgbValue {}

/// sRGB color space and nonlinear transfer function.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ColorRgba {
    pub red: u8,
    pub green: u8,
    pub blue: u8,
    pub alpha: u8,
}

impl fidl::Persistable for ColorRgba {}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a ColorRgba, and `value` is ignored.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ColorRgbaValue {
    pub value: ColorRgba,
    pub variable_id: u32,
}

impl fidl::Persistable for ColorRgbaValue {}

/// A Compositor draws its `LayerStack` into a framebuffer provided by its
/// attached `Display`, if any.  If no display is attached, nothing is rendered.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CompositorArgs {
    pub dummy: u32,
}

impl fidl::Persistable for CompositorArgs {}

/// Instructs the compositor to create the specified `Resource`, and to register
/// it in a table so that it can be referenced by subsequent commands.
#[derive(Debug, PartialEq)]
pub struct CreateResourceCmd {
    /// An ID that is currently not used within the session.
    pub id: u32,
    pub resource: ResourceArgs,
}

impl fidl::Standalone for CreateResourceCmd {}

/// Detaches all of a node's children (but not its parts).
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DetachChildrenCmd {
    pub node_id: u32,
}

impl fidl::Persistable for DetachChildrenCmd {}

/// Detaches a parentable object from its parent (e.g. a node from a parent node,
/// or a layer from a layer stack).  It is illegal to apply this command to a
/// non-parentable object.  No-op if the target object currently has no parent.
///
/// Constraints:
/// - `id` refs a parentable object
///
/// Discussion:
/// For nodes, this command will detach a node from its parent, regardless of
/// whether it is a part or a child of its parent.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DetachCmd {
    pub id: u32,
}

impl fidl::Persistable for DetachCmd {}

/// Detach the light specified by `light_id` from the scene that it is attached
/// to, if any.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DetachLightCmd {
    pub light_id: u32,
}

impl fidl::Persistable for DetachLightCmd {}

/// Detach all lights from the scene specified by `scene_id`.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DetachLightsCmd {
    pub scene_id: u32,
}

impl fidl::Persistable for DetachLightsCmd {}

/// A DirectionalLight is a Light that is emitted from a point at infinity.
///
/// Although the light is directional, the light has some amount of angular
/// dispersion (i.e., the light is not fully columnated). For simplicity, we
/// assume the dispersion of the light source is symmetric about the light's
/// primary direction.
///
/// Supported commands:
/// - SetLightColor
/// - SetLightDirection
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DirectionalLightArgs {
    pub dummy: u32,
}

impl fidl::Persistable for DirectionalLightArgs {}

/// A DisplayCompositor draws its attached `LayerStack` into an image that is
/// presented on a display.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DisplayCompositorArgs {
    pub dummy: u32,
}

impl fidl::Persistable for DisplayCompositorArgs {}

/// Provides information about a display.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DisplayInfo {
    /// The size of the display, in physical pixels.
    pub width_in_px: u32,
    pub height_in_px: u32,
}

impl fidl::Persistable for DisplayInfo {}

/// Characteristics:
/// - has_transform
/// - has_children
/// - has_parent
/// - has_parts
/// - has_clip
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct EntityNodeArgs {
    pub unused: u32,
}

impl fidl::Persistable for EntityNodeArgs {}

/// Create an external reference to the specified resource, which can then be
/// imported into another Session by passing a handle to `token`'s peer to
/// ImportResourceCmd; see that comment for more details.
///
/// The importing client is typically in a different process than the exporter.
/// No specific mechanism is provided for transferring a token from an exporter
/// to an importer; collaborators may choose any out-of-band API they wish to do
/// so.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ExportResourceCmdDeprecated {
    pub id: u32,
    pub token: fidl::EventPair,
}

impl fidl::Standalone for ExportResourceCmdDeprecated {}

/// Token that uniquely identifies a root point for a subgraph in the global
/// scene graph. Each `ExportToken` has exactly one corresponding `ImportToken`.
///
/// A Scenic client can have its contents referenced from another client by
/// creating a typed resource using this token.  The other client must also
/// create a correspondingly typed resource using the corresponding
/// `ImportToken`.
///
/// The exact nature of the inter-client reference depends on the specific
/// resources created from the tokens.  For example, creating a `View`
/// resource from this token allows everything attached to the `View` to be
/// embedded in another clients `ViewHolder`.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ExportToken {
    pub value: fidl::EventPair,
}

impl fidl::Standalone for ExportToken {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct FactoredTransform {
    pub translation: Vec3,
    pub scale: Vec3,
    /// Point around which rotation and scaling occur.
    pub anchor: Vec3,
    pub rotation: Quaternion,
}

impl fidl::Persistable for FactoredTransform {}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a float32, and `value` is ignored.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct FloatValue {
    pub value: f32,
    pub variable_id: u32,
}

impl fidl::Persistable for FloatValue {}

/// An image mapped to a range of a `Memory` resource.
#[derive(Clone, Debug, PartialEq)]
pub struct ImageArgs {
    pub info: fidl_fuchsia_images::ImageInfo,
    pub memory_id: u32,
    pub memory_offset: u32,
}

impl fidl::Persistable for ImageArgs {}

/// An image mapped to a range of a `Memory` resource.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ImageArgs2 {
    pub width: u32,
    pub height: u32,
    /// The id of a `BufferCollection`. Before creating this resource, the
    /// buffer collection should be registered on the same `Session` with
    /// `RegisterBufferCollection` and it should have its contraints set.
    /// Once the buffers are allocated successfully (e.g. after calling
    /// `WaitForBuffersAllocated`), the collection's id can be used to create
    /// the image resource.
    pub buffer_collection_id: u32,
    /// The index of the VMO from the `BufferCollection` that backs this image.
    pub buffer_collection_index: u32,
}

impl fidl::Persistable for ImageArgs2 {}

/// An image that is backed by a `BufferCollection` registered with `Allocator`.
#[derive(Debug, PartialEq)]
pub struct ImageArgs3 {
    pub width: u32,
    pub height: u32,
    /// Image creation requires an allocated `BufferCollection` registered with Allocator.
    /// `import_token` should be the other end of a BufferCollectionExportToken that is
    /// successfully registered. All clients of the specified BufferCollection must have set
    /// their constraints and buffers should be allocated before calling.
    pub import_token: fidl_fuchsia_ui_composition::BufferCollectionImportToken,
    /// The index of the VMO from the `BufferCollection` that backs this image.
    pub buffer_collection_index: u32,
}

impl fidl::Standalone for ImageArgs3 {}

/// `ImagePipe2` is a `Resource` that can be used as a `Texture` for a `Material`.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ImagePipe2Args {
    pub image_pipe_request: fidl::endpoints::ServerEnd<fidl_fuchsia_images::ImagePipe2Marker>,
}

impl fidl::Standalone for ImagePipe2Args {}

/// Import a resource that was exported via ExportResourceCmd().  `token` is
/// a handle to the eventpair peer that was used to export the resource, and
/// `spec` describes the type of the imported resource, and the commands which
/// can legally be applied to it.  Afterward, `id` can be used to refer to the
/// resource in an Command, similarly (but not identically: see below) to a
/// resource that was created in the session.  For example, you can add children
/// to an imported EntityNode via AddChildCmd.
///
/// However, note that the importer does not gain full access to the imported
/// resource, but rather to an attenuated subset of its capabilities.  For
/// example, you cannot use a DetachCmd to detach an imported EntityNode from
/// its parent.
///
/// Unlike ExportResourceCmd, there is no configurable timeout.  There is an
/// expectation that the exported resource will become available in a short
/// amount of time.  TODO: this needs elaboration... e.g. we might notify via the
/// SessionListener when we know that the link will never be made (e.g. if the
/// peer of the import token is destroyed).
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ImportResourceCmdDeprecated {
    pub id: u32,
    pub token: fidl::EventPair,
    pub spec: ImportSpec,
}

impl fidl::Standalone for ImportResourceCmdDeprecated {}

/// Token that uniquely identifies an attachment point for a subgraph in the
/// global scene graph.  Each `ImportToken` has exactly one corresponding
/// `ExportToken`.
///
/// A Scenic client can reference contents from another client by creating a
/// typed resource using this token.  The other client must also create a
/// correspondingly typed resource using the corresponding `ExportToken`.
///
/// The exact nature of the inter-client reference depends on the specific
/// resources created from the tokens.  For example, creating a `ViewHolder`
/// resource from this token allows a client to embed another client's `View`.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ImportToken {
    pub value: fidl::EventPair,
}

impl fidl::Standalone for ImportToken {}

/// Delivered when the imported resource with the given ID is no longer bound to
/// its host resource, or if the imported resource can not be bound because
/// the host resource is not available.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ImportUnboundEvent {
    pub resource_id: u32,
}

impl fidl::Persistable for ImportUnboundEvent {}

/// A Layer is a 2-dimensional image that is drawn by a Compositor.  The
/// contents of each Layer in a Layerstack are independent of each other.
/// A layer is not drawn unless it has a camera, texture, or color.
///
/// Supported commands:
/// - Detach
/// - SetCamera
/// - SetColor
/// - SetTexture
/// - SetSize (depth must be zero)
/// - SetSize
/// - SetTranslation (z component determines the relative Z-ordering of layers)
/// - SetRotation (must rotate around Z-axis)
/// - SetScale
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct LayerArgs {
    pub dummy: u32,
}

impl fidl::Persistable for LayerArgs {}

/// A LayerStack is a stack of layers that are attached to a Compositor, which
/// draws them in order of increasing Z-order (or rather, presents the illusion
/// of drawing them in that order: it may apply any optimizations that don't
/// affect the output).
///
/// Supported commands:
/// - AddLayer
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct LayerStackArgs {
    pub dummy: u32,
}

impl fidl::Persistable for LayerStackArgs {}

/// Simple texture-mapped material.
///
/// Supported commands:
/// - SetTextureCmd: sets the texture, or it can be left as zero (no texture).
///   The texture can be an Image or ImagePipe2.
/// - SetColorCmd: sets the color.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct MaterialArgs {
    pub dummy: u32,
}

impl fidl::Persistable for MaterialArgs {}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a vec4, and `value` is ignored.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct Matrix4Value {
    pub value: Mat4,
    pub variable_id: u32,
}

impl fidl::Persistable for Matrix4Value {}

/// `Memory` is a `Resource` that wraps a client-provided Zircon vmo to register
/// it with Scenic.
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MemoryArgs {
    /// The VMO which backs this memory.
    pub vmo: fidl::Vmo,
    /// The amount of memory from `vmo` that should be utilized.
    pub allocation_size: u64,
    /// The type of memory stored in the VMO, namely whether it's GPU memory or
    /// host memory.
    pub memory_type: fidl_fuchsia_images::MemoryType,
}

impl fidl::Standalone for MemoryArgs {}

/// A Mesh cannot be rendered until it has been bound to vertex/index buffers;
/// see BindMeshBuffersCmd.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MeshArgs;

impl fidl::Persistable for MeshArgs {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MeshVertexFormat {
    /// kVector2 or kVector3.
    pub position_type: ValueType,
    /// kVector2 or kVector3 (must match position_type), or kNone.
    pub normal_type: ValueType,
    /// kVector2 or kNone.
    pub tex_coord_type: ValueType,
}

impl fidl::Persistable for MeshVertexFormat {}

/// Rendering target metrics associated with a node.
/// See also `MetricsEvent`.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct Metrics {
    /// The ratio between the size of one logical pixel within the node's local
    /// coordinate system and the size of one physical pixel of the rendering
    /// target.
    ///
    /// This scale factors change in relation to the resolution of the rendering
    /// target and the scale transformations applied by containing nodes.
    /// They are always strictly positive and non-zero.
    ///
    /// For example, suppose the rendering target is a high resolution display
    /// with a device pixel ratio of 2.0 meaning that each logical pixel
    /// within the model corresponds to two physical pixels of the display.
    /// Assuming no scale transformations affect the node, then its metrics event
    /// will report a scale factor of 2.0.
    ///
    /// Building on this example, if instead the node's parent applies a
    /// scale transformation of 0.25 to the node, then the node's metrics event
    /// will report a scale factor of 0.5 indicating that the node should render
    /// its content at a reduced resolution and level of detail since a smaller
    /// area of physical pixels (half the size in each dimension) will be rendered.
    pub scale_x: f32,
    pub scale_y: f32,
    pub scale_z: f32,
}

impl fidl::Persistable for Metrics {}

/// Provides rendering target metrics information about the specified node.
///
/// This event is delivered when the following conditions are true:
/// - The node is a descendant of a `Scene`.
/// - The node has `kMetricsEventMask` set to an enabled state.
/// - The node's metrics have changed since they were last delivered, or since
///   `kMetricsEventMask` transitioned from a disabled state to an enabled state.
///
/// Subscribe to this event to receive information about the scale factors you
/// should apply when generating textures for your nodes.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct MetricsEvent {
    pub node_id: u32,
    pub metrics: Metrics,
}

impl fidl::Persistable for MetricsEvent {}

/// Characteristics:
/// - has_transform
/// - has_parent
/// - has_children
/// - has_parts
/// - has_opacity
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct OpacityNodeArgsHack {
    pub unused: u32,
}

impl fidl::Persistable for OpacityNodeArgsHack {}

/// Oriented plane described by a normal vector and a distance
/// from the origin along that vector.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct Plane3 {
    pub dir: Vec3,
    pub dist: f32,
}

impl fidl::Persistable for Plane3 {}

/// A PointLight is a Light that emits light in all directions.  By default, the
/// intensity of the light falls off according to the physically based
/// "inverse-square law" (see Wikipedia), although it can be adjusted to other
/// values for artistic effect.
///
/// Supported commands:
/// - SetLightColor
/// - SetPointLightPosition
/// - SetPointLightFalloff
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct PointLightArgs {
    pub dummy: u32,
}

impl fidl::Persistable for PointLightArgs {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct Quaternion {
    pub x: f32,
    pub y: f32,
    pub z: f32,
    pub w: f32,
}

impl fidl::Persistable for Quaternion {}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a Quaternion, and `value` is ignored.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct QuaternionValue {
    pub value: Quaternion,
    pub variable_id: u32,
}

impl fidl::Persistable for QuaternionValue {}

/// Rectangle centered at (0,0).
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct RectangleArgs {
    pub width: Value,
    pub height: Value,
}

impl fidl::Persistable for RectangleArgs {}

/// Releases the client's reference to the resource; it is then illegal to use
/// the ID in subsequent Commands.  Other references to the resource may exist,
/// so releasing the resource does not result in its immediate destruction; it is
/// only destroyed once the last reference is released.  For example, the
/// resource may be required to render an in-progress frame, or it may be
/// referred to by another resource).  However, the ID will be immediately
/// unregistered, and may be reused to create a new resource.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ReleaseResourceCmd {
    /// ID of the resource to be dereferenced.
    pub id: u32,
}

impl fidl::Persistable for ReleaseResourceCmd {}

/// Remove all layers from a layer stack.
/// Constraints
/// - `layer_stack_id` refs a `LayerStack`.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct RemoveAllLayersCmd {
    pub layer_stack_id: u32,
}

impl fidl::Persistable for RemoveAllLayersCmd {}

/// Remove a layer from a layer stack.
/// Constraints:
/// - `layer_stack_id` refs a `LayerStack`.
/// - `layer_id` refs a `Layer`.
/// - The layer must belong to this stack.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct RemoveLayerCmd {
    pub layer_stack_id: u32,
    pub layer_id: u32,
}

impl fidl::Persistable for RemoveLayerCmd {}

/// A Renderer renders a Scene via a Camera.
///
/// Supported commands:
/// - SetCamera
/// - SetRendererParam
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct RendererArgs {
    pub dummy: u32,
}

impl fidl::Persistable for RendererArgs {}

/// RoundedRectangle centered at (0,0).  Legal parameter values must satisfy the
/// constraint that the flat sides of the rectangle have non-negative length.
/// In other words, the following constraints must hold:
///   - top_left_radius + top_right_radius <= width
///   - bottom_left_radius + bottom_right_radius <= width
///   - top_left_radius + bottom_left_radius <= height
///   - top_right_radius + bottom_right_radius <= height
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct RoundedRectangleArgs {
    pub width: Value,
    pub height: Value,
    pub top_left_radius: Value,
    pub top_right_radius: Value,
    pub bottom_right_radius: Value,
    pub bottom_left_radius: Value,
}

impl fidl::Persistable for RoundedRectangleArgs {}

/// Adds the light specified by `light_id` specified by `light_id` to the scene
/// identified by `scene_id`.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SceneAddAmbientLightCmd {
    pub scene_id: u32,
    pub light_id: u32,
}

impl fidl::Persistable for SceneAddAmbientLightCmd {}

/// Adds the light specified by `light_id` specified by `light_id` to the scene
/// identified by `scene_id`.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SceneAddDirectionalLightCmd {
    pub scene_id: u32,
    pub light_id: u32,
}

impl fidl::Persistable for SceneAddDirectionalLightCmd {}

/// Adds the light specified by `light_id` specified by `light_id` to the scene
/// identified by `scene_id`.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SceneAddPointLightCmd {
    pub scene_id: u32,
    pub light_id: u32,
}

impl fidl::Persistable for SceneAddPointLightCmd {}

/// A Scene is the root of a scene-graph, and defines the rendering environment
/// (lighting, etc.) for the tree of nodes beneath it.
///
/// Supported commands:
/// - Add/RemoveLight
/// - AddChild
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SceneArgs {
    pub dummy: u32,
}

impl fidl::Persistable for SceneArgs {}

/// Sends a hint about a pending size change to the given node and all nodes
/// below. This is generally sent before an animation.
///
/// `width_change_factor` and `height_change_factor` is how much bigger or smaller
/// the item is expected to be in the near future. This one number encapsulate
/// both changes in scale, as well as changes to layout width and height.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SendSizeChangeHintCmdHack {
    pub node_id: u32,
    pub width_change_factor: f32,
    pub height_change_factor: f32,
}

impl fidl::Persistable for SendSizeChangeHintCmdHack {}

/// Sets a Resource's (typically a Node's) anchor point.
///
/// Constraints:
/// - `id` refs a Resource with the has_transform characteristic.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetAnchorCmd {
    pub id: u32,
    pub value: Vector3Value,
}

impl fidl::Persistable for SetAnchorCmd {}

/// Sets a camera's 2D clip-space transform.
///
/// Constraints:
/// - `camera_id` refs a `Camera`.
/// - `translation` is the desired translation, in Vulkan NDC.
/// - `scale` is the scale factor to apply on the x/y plane before translation.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetCameraClipSpaceTransformCmd {
    pub camera_id: u32,
    pub translation: Vec2,
    pub scale: f32,
}

impl fidl::Persistable for SetCameraClipSpaceTransformCmd {}

/// Sets a renderer's camera.
///
/// Constraints:
/// - `renderer_id` refs a `Renderer`.
/// - `camera_id` refs a `Camera`, or stops rendering by passing zero.
/// - `matrix` is a value or variable of type kMatrix4x4.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SetCameraCmd {
    pub renderer_id: u32,
    pub camera_id: u32,
}

impl fidl::Persistable for SetCameraCmd {}

/// Sets the "pose buffer" for the camera identified by `camera_id`.
/// This operation can be applied to both Cameras and StereoCameras.
///
/// This will override any position and rotation set for the camera and will
/// make it take its position and rotation from the pose buffer each frame
/// based on the presentation time for that frame.
///
/// A pose buffer represents a ring buffer of poses for a fixed number of time
/// points in the future. Each entry in the buffer identified by `buffer_id` is
/// a quaternion and a position layed out as follows:
///
/// struct Pose {
///   // Quaternion
///   float32 a;
///   float32 b;
///   float32 c;
///   float32 d;
///
///   // Position
///   float32 x;
///   float32 y;
///   float32 z;
///
///   // Reserved/Padding
///   byte[4] reserved;
/// }
///
/// The buffer can be thought of as a packed array of `num_entries` Pose structs
/// and is required to be at least num_entries * sizeof(Pose) bytes.
///
/// The quaternions and positions are specified in the space of the camera's
/// parent node.
///
/// `base_time` is a base time point expressed in nanoseconds in the
/// `CLOCK_MONOTONIC` timebase and `time_interval` is the time in nanoseconds
/// between entries in the buffer. `base_time` must be in the past.
///
/// For a given point in time `t` expressed in nanoseconds in the
/// `CLOCK_MONOTONIC` timebase the index of the corresponding pose in
/// the pose buffer can be computed as follows:
///
/// index(t) = ((t - base_time) / time_interval) % num_entries
///
/// poses[index(t)] is valid for t over the time interval (t - time_interval, t]
/// and should be expected to updated continuously without synchronization
/// for the duration of that interval. If a single pose value is needed for
/// multiple non-atomic operations a value should be latched and stored outside
/// the pose buffer.
///
/// Because the poses are not protected by any synchronization primitives it is
/// possible that when a pose is latched it will be only partially updated, and
/// the pose being read will contain some components from the pose before it is
/// updated and some components from the updated pose. The safety of using these
/// "torn" poses relies on two things:
///
/// 1) Sequential poses written to poses[index(t)] are very similar to each
/// other numerically, so that if some components are taken from the first and
/// some are taken from another the result is numerically similar to both
///
/// 2) The space of positions and quaternions is locally flat at the scale of
/// changes between sequential updates, which guarantees that two poses which
/// are numerically similar also represent semantically similar poses (i.e.
/// there are no discontinuities which will cause a small numerical change in
/// the position or quaterninon to cause a large change in the encoded pose)
/// For positions this is guaranteed because Scenic uses a Euclidean 3-space
/// which is globally flat and for quaternions this is guaranteed because
/// quaternions encode rotation as points on a unit 4-sphere, and spheres are
/// locally flat. For more details on the encoding of rotations in quaterions
/// see https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation
///
/// This commanderation is intended for late latching camera pose to support
/// low-latency motion-tracked rendering.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SetCameraPoseBufferCmd {
    pub camera_id: u32,
    pub buffer_id: u32,
    pub num_entries: u32,
    pub base_time: i64,
    pub time_interval: u64,
}

impl fidl::Persistable for SetCameraPoseBufferCmd {}

/// Sets a camera's projection matrix.
/// This operation cannot be applied to a StereoCamera.
///
/// Constraints:
/// - `camera_id` refs a `Camera` that is not a `StereoCamera`.
/// - `fovy` is the Y-axis field of view, in radians.
///
/// NOTE: A default orthographic projection is specified by setting `fovy` to
/// zero.  In this case, the camera transform is ignored.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetCameraProjectionCmd {
    pub camera_id: u32,
    pub fovy: FloatValue,
}

impl fidl::Persistable for SetCameraProjectionCmd {}

/// Sets a camera's view matrix.
/// This operation can be applied to both Cameras and StereoCameras.
///
/// Constraints:
/// - `camera_id` refs a `Camera`.
/// - `eye_position` is the position of the eye.
/// - `eye_look_at` is the point is the scene the that eye is pointed at.
/// - `eye_up` defines the camera's "up" vector.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetCameraTransformCmd {
    pub camera_id: u32,
    pub eye_position: Vector3Value,
    pub eye_look_at: Vector3Value,
    pub eye_up: Vector3Value,
}

impl fidl::Persistable for SetCameraTransformCmd {}

/// Sets/clears a node's clip.  DEPRECATED: use SetClipPlanesCmd.
///
/// Constraints:
/// - `node_id` refs a `Node` with the has_clip characteristic.
/// - `clip_id` a `Node` with the is_clip characteristic, or nothing.  If the
///   referenced node is not rooted, then it will have no effect (since its
///   full world-transform cannot be determined).
/// - `clip_to_self` If false, children are only clipped to the region specified
///   by `clip_id`.  If true, children are additionally clipped to the node's
///   shape (as determined by its ShapeNode parts).
///
/// Discussion:
/// If a node has a clip, it will be applied to both the parts and the children
/// of the node.  Under some circumstances (TBD), a clip will not be applicable
/// to a node; in such cases it will be as though no clip has been specified for
/// the node.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SetClipCmd {
    pub node_id: u32,
    pub clip_id: u32,
    pub clip_to_self: bool,
}

impl fidl::Persistable for SetClipCmd {}

/// Sets the list of clip planes that apply to a Node and all of its children.  Replaces
/// the list set by any previous SetClipPlanesCmd.
///
/// - `node_id` refs a `Node` with the has_clip characteristic.
/// - `clip_planes` is the new list of oriented clip planes.
#[derive(Clone, Debug, PartialEq, PartialOrd)]
pub struct SetClipPlanesCmd {
    pub node_id: u32,
    pub clip_planes: Vec<Plane3>,
}

impl fidl::Persistable for SetClipPlanesCmd {}

/// Sets a material's color.
///
/// Constraints:
/// - `material_id` refs a `Material`.
///
/// If a texture is set on the material, then the value sampled from the texture
/// is multiplied by the color.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SetColorCmd {
    pub material_id: u32,
    pub color: ColorRgbaValue,
}

impl fidl::Persistable for SetColorCmd {}

/// Set whether clipping should be disabled for the specified renderer.  For a
/// newly-created renderer, clipping will NOT be disabled (i.e. it will be
/// enabled).
///
/// NOTE: this disables visual clipping only; objects are still clipped for the
/// purposes of hit-testing.
///
/// `renderer_id` refs the target renderer.
/// `disable_clipping` specifies whether the clipping should be disabled.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SetDisableClippingCmd {
    pub renderer_id: u32,
    pub disable_clipping: bool,
}

impl fidl::Persistable for SetDisableClippingCmd {}

/// Set the color conversion applied to the compositor's display.
/// The conversion is applied to to each pixel according to the formula:
///
/// (matrix * (pixel + preoffsets)) + postoffsets
///
/// where pixel is a column vector consisting of the pixel's 3 components.
///
/// `matrix` is passed in row-major order. Clients will be responsible
/// for passing default values, when needed.
/// Default values are not currently supported in fidl.
/// Default Values:
///   preoffsets = [0 0 0]
///   matrix = [1 0 0 0 1 0 0 0 1]
///   postoffsets = [0 0 0]
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetDisplayColorConversionCmdHack {
    pub compositor_id: u32,
    pub preoffsets: [f32; 3],
    pub matrix: [f32; 9],
    pub postoffsets: [f32; 3],
}

impl fidl::Persistable for SetDisplayColorConversionCmdHack {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SetDisplayMinimumRgbCmdHack {
    pub min_value: u8,
}

impl fidl::Persistable for SetDisplayMinimumRgbCmdHack {}

/// Depending on the device, the display might be rotated
/// with respect to what the lower level device controller
/// considers the physical orientation of pixels. The
/// compositors and layers must be in alignment with the
/// underlying physical orientation which means that for
/// certain operations like screenshotting, they cannot
/// provide results with the accurate orientation unless
/// they have information about how the higher-level display
/// is orienting the screen. The only legal values for the
/// rotation are 0, 90, 180, and 270, which are each
///  applied counterclockwise.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SetDisplayRotationCmdHack {
    pub compositor_id: u32,
    pub rotation_degrees: u32,
}

impl fidl::Persistable for SetDisplayRotationCmdHack {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SetEnableDebugViewBoundsCmd {
    pub view_id: u32,
    pub enable: bool,
}

impl fidl::Persistable for SetEnableDebugViewBoundsCmd {}

/// Sets which events a resource should deliver to the session listener.
/// This command replaces any prior event mask for the resource.
///
/// The initial event mask for a resource is zero, meaning no events are
/// reported.
///
/// Constraints:
/// - `resource_id` is a valid resource id
/// - `event_mask` is zero or a combination of `k*EventMask` bits OR'ed together.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SetEventMaskCmd {
    pub id: u32,
    pub event_mask: u32,
}

impl fidl::Persistable for SetEventMaskCmd {}

/// Sets a node's hit test behavior.
///
/// Discussion:
/// By default, hit testing is performed on the node's content, its parts,
/// and its children.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SetHitTestBehaviorCmd {
    pub node_id: u32,
    pub hit_test_behavior: HitTestBehavior,
}

impl fidl::Persistable for SetHitTestBehaviorCmd {}

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

impl fidl::Persistable for SetImportFocusCmdDeprecated {}

/// Sets/clears a label to help developers identify the purpose of the resource
/// when using diagnostic tools.
///
/// The label serves no functional purpose in the scene graph.  It exists only
/// to help developers understand its structure.  The scene manager may truncate
/// or discard labels at will.
///
/// Constraints:
/// - The label's maximum length is `kLabelMaxLength` characters.
/// - Setting the label to an empty string clears it.
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SetLabelCmd {
    pub id: u32,
    pub label: String,
}

impl fidl::Persistable for SetLabelCmd {}

/// Set a compositor's layer stack, replacing the current stack (if any).
/// Constraints:
/// - `compositor_id` refs a `DisplayCompositor`.
/// - `layer_stack_id` refs a `LayerStack`.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SetLayerStackCmd {
    pub compositor_id: u32,
    pub layer_stack_id: u32,
}

impl fidl::Persistable for SetLayerStackCmd {}

/// Sets the color of the Light identified by `light_id`.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetLightColorCmd {
    pub light_id: u32,
    pub color: ColorRgbValue,
}

impl fidl::Persistable for SetLightColorCmd {}

/// Sets the direction of the DirectionalLight identified by `light_id`.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetLightDirectionCmd {
    pub light_id: u32,
    pub direction: Vector3Value,
}

impl fidl::Persistable for SetLightDirectionCmd {}

/// Sets/clears a node's material.
///
/// Constraints:
/// - `node_id` refs a `Node` with the has_material characteristic.
/// - `material_id` refs a `Material`, or nothing.
/// - if this command causes the target to have both a `Shape` and a `Material`,
///   then these must be compatible with each other (see README.md regarding
///   "Shape/Material Compatibility").
///
/// Discussion:
/// In order to be painted, a node requires both a `Shape` and a `Material`.
/// Without a material, a node can still participate in hit-testing and clipping.
/// Without a shape, a node cannot do any of the above.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SetMaterialCmd {
    pub node_id: u32,
    pub material_id: u32,
}

impl fidl::Persistable for SetMaterialCmd {}

/// Sets a node's opacity.
///
/// Constraints:
/// - `node_id` refs a `Node` with the has_opacity characteristic.
/// - `opacity` is in the range [0, 1].
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetOpacityCmd {
    pub node_id: u32,
    pub opacity: f32,
}

impl fidl::Persistable for SetOpacityCmd {}

/// Sets the falloff factor of the PointLight identified by `light_id`.
/// A value of 1.0 corresponds to the physically-based "inverse-square law"
/// (see Wikipedia).  Other values can be used for artistic effect, e.g. a
/// value of 0.0 means that the radiance of a surface is not dependant on
/// its distance from the light.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetPointLightFalloffCmd {
    pub light_id: u32,
    pub falloff: FloatValue,
}

impl fidl::Persistable for SetPointLightFalloffCmd {}

/// Sets the position of the PointLight identified by `light_id`.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetPointLightPositionCmd {
    pub light_id: u32,
    pub position: Vector3Value,
}

impl fidl::Persistable for SetPointLightPositionCmd {}

/// Set a layer's renderer, replacing the current renderer (if any).
/// Constraints:
/// - `layer_id` refs a `Layer`.
/// - `renderer_id` refs a `Renderer`.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SetRendererCmd {
    pub layer_id: u32,
    pub renderer_id: u32,
}

impl fidl::Persistable for SetRendererCmd {}

/// Sets a parameter that affects how a renderer renders a scene.
///
/// `renderer_id` refs the Renderer that is being modified.
/// `param` describes the parameter that should be set, and to what.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SetRendererParamCmd {
    pub renderer_id: u32,
    pub param: RendererParam,
}

impl fidl::Persistable for SetRendererParamCmd {}

/// Sets a Resource's (typically a Node's) rotation.
///
/// Constraints:
/// - `id` refs a Resource with the has_transform characteristic.
///
/// Discussion:
/// Quaternions represent any rotation in a 3D coordinate system. Consisting of
/// [a,b,c,d], [a] represents the amount of rotation that should be applied and
/// [b,c,d] represents the vector around which the rotation is applied. This
/// conforms to the semantics of glm::quat.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetRotationCmd {
    pub id: u32,
    pub value: QuaternionValue,
}

impl fidl::Persistable for SetRotationCmd {}

/// Sets a Resource's (typically a Node's) scale.
///
/// Constraints:
/// - `id` refs a Resource with the has_transform characteristic.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetScaleCmd {
    pub id: u32,
    pub value: Vector3Value,
}

impl fidl::Persistable for SetScaleCmd {}

/// Sets a node's semantic visibility.
///
/// Discussion:
/// By default, all nodes are semantically visible. Semantically invisible nodes and their children
/// are ignored by hit tests performed for accessibility.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SetSemanticVisibilityCmd {
    pub node_id: u32,
    pub visible: bool,
}

impl fidl::Persistable for SetSemanticVisibilityCmd {}

/// Sets/clears a node's shape.
///
/// Constraints:
/// - `node_id` refs a `Node` with the has_shape characteristic.
/// - `shape_id` refs a `Shape`, or nothing.
/// - if this command causes the target to have both a `Shape` and a `Material`,
///   then these must be compatible with each other (see README.md regarding
///   "Shape/Material Compatibility").
///
/// Discussion:
/// In order to be painted, a node requires both a `Shape` and a `Material`.
/// Without a material, a node can still participate in hit-testing and clipping.
/// Without a shape, a node cannot do any of the above.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SetShapeCmd {
    pub node_id: u32,
    pub shape_id: u32,
}

impl fidl::Persistable for SetShapeCmd {}

/// Sets an object's size.
///
/// Constraints:
/// - `id` refs a resizeable object.
/// - some objects that support this command may have additional constraints
///   (e.g. in some cases `depth` must be zero).
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetSizeCmd {
    pub id: u32,
    pub value: Vector2Value,
}

impl fidl::Persistable for SetSizeCmd {}

/// Sets a StereoCamera's projection matrices.
/// This operation can only be applied to a StereoCamera.
///
/// Constraints:
/// - `camera_id` refs a `StereoCamera`.
/// - `left_projection` is the projection matrix for the left eye.
/// - `right_projection` is the projection matrix for the right eye.
///
/// These projection matrices may also contain a transform in camera space for
/// their eye if needed.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetStereoCameraProjectionCmd {
    pub camera_id: u32,
    pub left_projection: Matrix4Value,
    pub right_projection: Matrix4Value,
}

impl fidl::Persistable for SetStereoCameraProjectionCmd {}

/// Sets/clears a node's tag value.
///
/// A session can apply a tag value to any node to which it has access, including
/// imported nodes.  These tags are private to the session and cannot be read
/// or modified by other sessions.  When multiple sessions import the same node,
/// each session will only observe its own tag values.
///
/// Hit test results for a session only include nodes which the session has
/// tagged with a non-zero value.  Therefore a session can use tag values to
/// associate nodes with their functional purpose when picked.
///
/// Constraints:
/// - `node_id` refs a `Node`.
/// - `tag_value` is the tag value to assign, or 0 to remove the tag.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SetTagCmd {
    pub node_id: u32,
    pub tag_value: u32,
}

impl fidl::Persistable for SetTagCmd {}

/// Sets/clears a material's texture.
///
/// Constraints:
/// - `material_id` refs a `Material`.
/// - `texture_id` refs a `Image`, `ImagePipe2`, or nothing.
///
/// If no texture is provided (i.e. `texture_id` is zero), a solid color is used.
/// If a texture is provided, then the value sampled from the texture is
/// multiplied by the color.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct SetTextureCmd {
    pub material_id: u32,
    pub texture_id: u32,
}

impl fidl::Persistable for SetTextureCmd {}

/// Sets a Resource's (typically a Node's) translation.
///
/// Constraints:
/// - `id` refs a Resource with the has_transform characteristic.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetTranslationCmd {
    pub id: u32,
    pub value: Vector3Value,
}

impl fidl::Persistable for SetTranslationCmd {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetViewHolderBoundsColorCmd {
    pub view_holder_id: u32,
    pub color: ColorRgbValue,
}

impl fidl::Persistable for SetViewHolderBoundsColorCmd {}

/// Sets the properties for a ViewHolder's attached View.
///
/// Constraints:
/// - `view_holder_id` refs a `ViewHolder`.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SetViewPropertiesCmd {
    pub view_holder_id: u32,
    pub properties: ViewProperties,
}

impl fidl::Persistable for SetViewPropertiesCmd {}

/// Characteristics:
/// - has_parent
/// - has_shape
/// - has_material
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ShapeNodeArgs {
    pub unused: u32,
}

impl fidl::Persistable for ShapeNodeArgs {}

/// Delivered in response to a size change hint from a parent node
/// (SendSizeChangeHintCmd).
///
/// This event is delivered when the following conditions are true:
/// - The node has `kSizeChangeEventMask` set to an enabled state.
/// - A parent node has sent a SendSizeChangeHintCmd.
///
/// Subscribe to this event to receive information about how large textures you
/// will need in the near future for your nodes. The canonical use case is to
/// pre-allocate memory to avoid repeated re-allocations.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct SizeChangeHintEvent {
    pub node_id: u32,
    pub width_change_factor: f32,
    pub height_change_factor: f32,
}

impl fidl::Persistable for SizeChangeHintEvent {}

#[derive(Debug, PartialEq)]
pub struct SnapshotCallbackDeprecatedOnDataRequest {
    pub data: fidl_fuchsia_mem::Buffer,
}

impl fidl::Standalone for SnapshotCallbackDeprecatedOnDataRequest {}

/// A StereoCamera is a Camera that renders the scene in side-by-side stereo.
///
/// Any command which can be applied to a Camera can also be applied to a
/// StereoCamera.
/// Additional supported commands:
/// - SetStereoCameraProjection
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct StereoCameraArgs {
    /// The scene that the camera is viewing.
    pub scene_id: u32,
}

impl fidl::Persistable for StereoCameraArgs {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TakeSnapshotCmdDeprecated {
    pub node_id: u32,
    pub callback: fidl::endpoints::ClientEnd<SnapshotCallbackDeprecatedMarker>,
}

impl fidl::Standalone for TakeSnapshotCmdDeprecated {}

/// Describes a typed, client-modifiable value.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct VariableArgs {
    pub type_: ValueType,
    pub initial_value: Value,
}

impl fidl::Persistable for VariableArgs {}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a vec2, and `value` is ignored.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct Vector2Value {
    pub value: Vec2,
    pub variable_id: u32,
}

impl fidl::Persistable for Vector2Value {}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a vec3, and `value` is ignored.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct Vector3Value {
    pub value: Vec3,
    pub variable_id: u32,
}

impl fidl::Persistable for Vector3Value {}

/// A value that is specified explicitly by `value` if `variable_id` is zero,
/// or is the value produced by the resource identified by `variable_id`, e.g.
/// an animation or expression.  In the latter case, the value produced by the
/// resource must be a vec4, and `value` is ignored.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct Vector4Value {
    pub value: Vec4,
    pub variable_id: u32,
}

impl fidl::Persistable for Vector4Value {}

/// Represents the root of a subgraph within a larger scene graph.  Nodes can be
/// attached to the `View` as children, and these Nodes will have the `View`s'
/// coordinate transform applied to their own, in addition to being clipped to
/// the `View`s' bounding box.
/// See `ViewProperties`.
///
/// Each `View` is linked to a paired `ViewHolder` via a shared token pair.
///
/// Usually the `View` and its associated `ViewHolder` exist in separate
/// processes.  By combining them, the UI for an entire system can be built
/// using content contributed from many different processes.
#[derive(Debug, PartialEq)]
pub struct ViewArgs {
    pub token: fidl_fuchsia_ui_views::ViewToken,
    pub debug_name: Option<String>,
}

impl fidl::Standalone for ViewArgs {}

/// Represents the root of a subgraph within a larger scene graph.  Nodes can be
/// attached to the `View` as children, and these Nodes will have the `View`s'
/// coordinate transform applied to their own, in addition to being clipped to
/// the `View`s' bounding box.
/// See `ViewProperties`.
///
/// Each `View` is linked to a paired `ViewHolder` via a shared token pair.
///
/// Usually the `View` and its associated `ViewHolder` exist in separate
/// processes.  By combining them, the UI for an entire system can be built
/// using content contributed from many different processes.
///
/// Clients self-identify their `View` with a `ViewRef`, which is a stable
/// identifier that may be cloned and passed to other components in a
/// feed-forward style. It is accompanied by a `ViewRefControl`, which Scenic
/// uses to signal `View` destruction across the system; the `ViewRefControl`
/// must be unique - do not clone it.
#[derive(Debug, PartialEq)]
pub struct ViewArgs3 {
    pub token: fidl_fuchsia_ui_views::ViewToken,
    /// `control_ref.reference` must have default eventpair rights (i.e., with
    /// signaling), minus ZX_RIGHT_DUPLICATE.
    pub control_ref: fidl_fuchsia_ui_views::ViewRefControl,
    /// `view_ref.reference` must have basic rights (i.e., no signaling).
    pub view_ref: fidl_fuchsia_ui_views::ViewRef,
    pub debug_name: Option<String>,
}

impl fidl::Standalone for ViewArgs3 {}

/// Delivered to a View's Session when the parent ViewHolder for the given View
/// becomes a part of a Scene.
///
/// A ViewHolder is considered to be part of a Scene if there is an unbroken
/// chain of parent-child relationships between the Scene node and the
/// ViewHolder node.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct ViewAttachedToSceneEvent {
    pub view_id: u32,
    pub properties: ViewProperties,
}

impl fidl::Persistable for ViewAttachedToSceneEvent {}

/// Delivered to a ViewHolder's Session when its peer View is connected.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ViewConnectedEvent {
    pub view_holder_id: u32,
}

impl fidl::Persistable for ViewConnectedEvent {}

/// Delivered to a View's Session when the parent ViewHolder for the given View
/// is no longer part of a scene.
///
/// This can happen if the ViewHolder is detached directly from the scene, or
/// if one of its parent nodes is.
///
/// A ViewHolder is considered to be part of a Scene if there is an unbroken
/// chain of parent-child relationships between the Scene node and the
/// ViewHolder node.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ViewDetachedFromSceneEvent {
    pub view_id: u32,
}

impl fidl::Persistable for ViewDetachedFromSceneEvent {}

/// Delivered to a ViewHolder's Session when its peer View is disconnected or
/// destroyed.
///
/// If the View is destroyed before the connection is established, then this
/// event will be delivered immediately when the ViewHolder attempts to connect.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ViewDisconnectedEvent {
    pub view_holder_id: u32,
}

impl fidl::Persistable for ViewDisconnectedEvent {}

/// Represents an attachment point for a subgraph within a larger scene graph.
/// The `ViewHolder` can be attached to a Node as a child, and the contents of
/// the linked `View` will become a child of the Node as well.
///
/// Each `ViewHolder` is linked to a paired `View` via a shared token pair.
///
/// Usually the `ViewHolder` and its associated `View` exist in separate
/// processes.  By combining them, the UI for an entire system can be built
/// using content contributed from many different processes.
#[derive(Debug, PartialEq)]
pub struct ViewHolderArgs {
    pub token: fidl_fuchsia_ui_views::ViewHolderToken,
    pub debug_name: Option<String>,
}

impl fidl::Standalone for ViewHolderArgs {}

/// Delivered to a View's Session when its peer ViewHolder is connected.
///
/// If the ViewHolder is destroyed before the connection is established, then
/// this event will not be delivered.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ViewHolderConnectedEvent {
    pub view_id: u32,
}

impl fidl::Persistable for ViewHolderConnectedEvent {}

/// Delivered to a View's Session when its peer ViewHolder is disconnected or
/// destroyed.
///
/// If the ViewHolder is destroyed before the connection is established, then
/// this event will be delivered immediately when the View attempts to connect.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ViewHolderDisconnectedEvent {
    pub view_id: u32,
}

impl fidl::Persistable for ViewHolderDisconnectedEvent {}

/// Represents the properties for a View.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct ViewProperties {
    /// The View's bounding box extents can be defined as:
    ///    { bounding_box.min, bounding_box.max }
    /// Content contained within the View is clipped to this bounding box.
    pub bounding_box: BoundingBox,
    /// `insets_from_min` and `insets_from_max` specify the distances between the
    /// view's bounding box and that of its parent.
    ///
    /// These properties are not strictly enforced by Scenic, but only used
    /// as hints for clients and other components that receives ViewProperties:
    ///
    /// View clients can assume that anything drawn outside of
    ///    { bounding_box.min + inset_from_min, bounding_box.max - inset_from_max }
    /// may be obscured by an ancestor view. The reason for obscuring, and the rules
    /// surrounding it, is specific to each product.
    pub inset_from_min: Vec3,
    pub inset_from_max: Vec3,
    /// Whether the View can receive a focus event; default is true.  When
    /// false, and this View is eligible to receive a focus event, no
    /// focus/unfocus event is actually sent to any View.
    pub focus_change: bool,
    /// Whether the View allows geometrically underlying Views to receive input;
    /// default is true. When false, Scenic does not send input events to
    /// underlying Views.
    pub downward_input: bool,
}

impl fidl::Persistable for ViewProperties {}

/// Delivered when the parent ViewHolder for the given View makes a change to
/// the View's properties.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct ViewPropertiesChangedEvent {
    pub view_id: u32,
    pub properties: ViewProperties,
}

impl fidl::Persistable for ViewPropertiesChangedEvent {}

/// Represents the state of a View in Scenic.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ViewState {
    /// Whether the View is rendering. Default is false. Delivered to the View's
    /// corresponding ViewHolder after the View's first frame render request.
    pub is_rendering: bool,
}

impl fidl::Persistable for ViewState {}

/// Delivered to a ViewHolder's Session when its peer View's state has changed.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ViewStateChangedEvent {
    pub view_holder_id: u32,
    pub state: ViewState,
}

impl fidl::Persistable for ViewStateChangedEvent {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct Mat4 {
    /// Column major order.
    pub matrix: [f32; 16],
}

impl fidl::Persistable for Mat4 {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct Vec2 {
    pub x: f32,
    pub y: f32,
}

impl fidl::Persistable for Vec2 {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct Vec3 {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}

impl fidl::Persistable for Vec3 {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct Vec4 {
    pub x: f32,
    pub y: f32,
    pub z: f32,
    pub w: f32,
}

impl fidl::Persistable for Vec4 {}

/// Commands that are used to modify the state of a `Session`.
#[derive(Debug, PartialEq)]
pub enum Command {
    CreateResource(CreateResourceCmd),
    ReleaseResource(ReleaseResourceCmd),
    ExportResource(ExportResourceCmdDeprecated),
    ImportResource(ImportResourceCmdDeprecated),
    /// Tagging commands.
    SetTag(SetTagCmd),
    /// Grouping commands.
    Detach(DetachCmd),
    /// Spatial commands.
    SetTranslation(SetTranslationCmd),
    SetScale(SetScaleCmd),
    SetRotation(SetRotationCmd),
    SetAnchor(SetAnchorCmd),
    SetSize(SetSizeCmd),
    SetOpacity(SetOpacityCmd),
    SendSizeChangeHintHack(SendSizeChangeHintCmdHack),
    /// Node-specific commands.
    AddChild(AddChildCmd),
    /// re-parenting?
    AddPart(AddPartCmd),
    DetachChildren(DetachChildrenCmd),
    SetShape(SetShapeCmd),
    SetMaterial(SetMaterialCmd),
    SetClip(SetClipCmd),
    SetHitTestBehavior(SetHitTestBehaviorCmd),
    SetViewProperties(SetViewPropertiesCmd),
    TakeSnapshotCmd(TakeSnapshotCmdDeprecated),
    /// Camera and lighting commands.
    SetCamera(SetCameraCmd),
    SetCameraTransform(SetCameraTransformCmd),
    SetCameraProjection(SetCameraProjectionCmd),
    SetStereoCameraProjection(SetStereoCameraProjectionCmd),
    SetCameraPoseBuffer(SetCameraPoseBufferCmd),
    SetLightColor(SetLightColorCmd),
    SetLightDirection(SetLightDirectionCmd),
    AddLight(AddLightCmd),
    DetachLight(DetachLightCmd),
    DetachLights(DetachLightsCmd),
    SetTexture(SetTextureCmd),
    SetColor(SetColorCmd),
    /// Mesh commands.
    BindMeshBuffers(BindMeshBuffersCmd),
    /// Layer and renderer commands.
    AddLayer(AddLayerCmd),
    RemoveLayer(RemoveLayerCmd),
    RemoveAllLayers(RemoveAllLayersCmd),
    SetLayerStack(SetLayerStackCmd),
    SetRenderer(SetRendererCmd),
    SetRendererParam(SetRendererParamCmd),
    /// Events.
    SetEventMask(SetEventMaskCmd),
    /// Diagnostic commands.
    SetLabel(SetLabelCmd),
    /// Debugging commands.
    SetDisableClipping(SetDisableClippingCmd),
    SetImportFocus(SetImportFocusCmdDeprecated),
    SetClipPlanes(SetClipPlanesCmd),
    SetPointLightPosition(SetPointLightPositionCmd),
    SetPointLightFalloff(SetPointLightFalloffCmd),
    Scene_AddAmbientLight(SceneAddAmbientLightCmd),
    Scene_AddDirectionalLight(SceneAddDirectionalLightCmd),
    Scene_AddPointLight(SceneAddPointLightCmd),
    SetDisplayColorConversion(SetDisplayColorConversionCmdHack),
    SetDisplayRotation(SetDisplayRotationCmdHack),
    SetEnableViewDebugBounds(SetEnableDebugViewBoundsCmd),
    SetViewHolderBoundsColor(SetViewHolderBoundsColorCmd),
    SetCameraClipSpaceTransform(SetCameraClipSpaceTransformCmd),
    SetDisplayMinimumRgb(SetDisplayMinimumRgbCmdHack),
    SetSemanticVisibility(SetSemanticVisibilityCmd),
}

impl Command {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::CreateResource(_) => 1,
            Self::ReleaseResource(_) => 2,
            Self::ExportResource(_) => 3,
            Self::ImportResource(_) => 4,
            Self::SetTag(_) => 5,
            Self::Detach(_) => 6,
            Self::SetTranslation(_) => 7,
            Self::SetScale(_) => 8,
            Self::SetRotation(_) => 9,
            Self::SetAnchor(_) => 10,
            Self::SetSize(_) => 11,
            Self::SetOpacity(_) => 12,
            Self::SendSizeChangeHintHack(_) => 13,
            Self::AddChild(_) => 14,
            Self::AddPart(_) => 15,
            Self::DetachChildren(_) => 16,
            Self::SetShape(_) => 17,
            Self::SetMaterial(_) => 18,
            Self::SetClip(_) => 19,
            Self::SetHitTestBehavior(_) => 20,
            Self::SetViewProperties(_) => 21,
            Self::TakeSnapshotCmd(_) => 22,
            Self::SetCamera(_) => 23,
            Self::SetCameraTransform(_) => 24,
            Self::SetCameraProjection(_) => 25,
            Self::SetStereoCameraProjection(_) => 26,
            Self::SetCameraPoseBuffer(_) => 27,
            Self::SetLightColor(_) => 28,
            Self::SetLightDirection(_) => 29,
            Self::AddLight(_) => 30,
            Self::DetachLight(_) => 31,
            Self::DetachLights(_) => 32,
            Self::SetTexture(_) => 33,
            Self::SetColor(_) => 34,
            Self::BindMeshBuffers(_) => 35,
            Self::AddLayer(_) => 36,
            Self::RemoveLayer(_) => 37,
            Self::RemoveAllLayers(_) => 38,
            Self::SetLayerStack(_) => 39,
            Self::SetRenderer(_) => 40,
            Self::SetRendererParam(_) => 41,
            Self::SetEventMask(_) => 42,
            Self::SetLabel(_) => 43,
            Self::SetDisableClipping(_) => 44,
            Self::SetImportFocus(_) => 45,
            Self::SetClipPlanes(_) => 46,
            Self::SetPointLightPosition(_) => 47,
            Self::SetPointLightFalloff(_) => 48,
            Self::Scene_AddAmbientLight(_) => 49,
            Self::Scene_AddDirectionalLight(_) => 50,
            Self::Scene_AddPointLight(_) => 51,
            Self::SetDisplayColorConversion(_) => 52,
            Self::SetDisplayRotation(_) => 53,
            Self::SetEnableViewDebugBounds(_) => 54,
            Self::SetViewHolderBoundsColor(_) => 55,
            Self::SetCameraClipSpaceTransform(_) => 56,
            Self::SetDisplayMinimumRgb(_) => 57,
            Self::SetSemanticVisibility(_) => 58,
        }
    }

    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

impl fidl::Standalone for Command {}

/// These are all of the types of events which can be reported by a `Session`.
/// Use `SetEventMaskCmd` to enable event delivery for a resource.
#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub enum Event {
    /// Events which are controlled by a mask.
    Metrics(MetricsEvent),
    SizeChangeHint(SizeChangeHintEvent),
    /// Events which are always delivered, regardless of mask.
    ImportUnbound(ImportUnboundEvent),
    ViewConnected(ViewConnectedEvent),
    ViewDisconnected(ViewDisconnectedEvent),
    ViewHolderDisconnected(ViewHolderDisconnectedEvent),
    ViewAttachedToScene(ViewAttachedToSceneEvent),
    ViewDetachedFromScene(ViewDetachedFromSceneEvent),
    ViewPropertiesChanged(ViewPropertiesChangedEvent),
    ViewStateChanged(ViewStateChangedEvent),
    ViewHolderConnected(ViewHolderConnectedEvent),
}

impl Event {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Metrics(_) => 1,
            Self::SizeChangeHint(_) => 2,
            Self::ImportUnbound(_) => 3,
            Self::ViewConnected(_) => 4,
            Self::ViewDisconnected(_) => 5,
            Self::ViewHolderDisconnected(_) => 6,
            Self::ViewAttachedToScene(_) => 7,
            Self::ViewDetachedFromScene(_) => 8,
            Self::ViewPropertiesChanged(_) => 9,
            Self::ViewStateChanged(_) => 10,
            Self::ViewHolderConnected(_) => 11,
        }
    }

    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

impl fidl::Persistable for Event {}

/// These are all of the types of parameters that can be set to configure a
/// `Renderer`.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum RendererParam {
    ShadowTechnique(ShadowTechnique),
    Reserved(RenderFrequency),
    EnableDebugging(bool),
}

impl RendererParam {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::ShadowTechnique(_) => 1,
            Self::Reserved(_) => 2,
            Self::EnableDebugging(_) => 3,
        }
    }

    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

impl fidl::Persistable for RendererParam {}

/// These are all of the types of resources that can be created within a
/// `Session`. Add new fields only to the bottom of the list.
#[derive(Debug, PartialEq)]
pub enum ResourceArgs {
    Memory(MemoryArgs),
    Image(ImageArgs),
    Buffer(BufferArgs),
    View(ViewArgs),
    ViewHolder(ViewHolderArgs),
    Rectangle(RectangleArgs),
    RoundedRectangle(RoundedRectangleArgs),
    Circle(CircleArgs),
    Mesh(MeshArgs),
    ShapeNode(ShapeNodeArgs),
    ClipNode(ClipNodeArgs),
    EntityNode(EntityNodeArgs),
    OpacityNode(OpacityNodeArgsHack),
    Material(MaterialArgs),
    Compositor(CompositorArgs),
    DisplayCompositor(DisplayCompositorArgs),
    LayerStack(LayerStackArgs),
    Layer(LayerArgs),
    Scene(SceneArgs),
    Camera(CameraArgs),
    StereoCamera(StereoCameraArgs),
    Renderer(RendererArgs),
    AmbientLight(AmbientLightArgs),
    DirectionalLight(DirectionalLightArgs),
    Variable(VariableArgs),
    PointLight(PointLightArgs),
    View3(ViewArgs3),
    ImagePipe2(ImagePipe2Args),
    Image2(ImageArgs2),
    Image3(ImageArgs3),
}

impl ResourceArgs {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Memory(_) => 1,
            Self::Image(_) => 2,
            Self::Buffer(_) => 4,
            Self::View(_) => 5,
            Self::ViewHolder(_) => 6,
            Self::Rectangle(_) => 7,
            Self::RoundedRectangle(_) => 8,
            Self::Circle(_) => 9,
            Self::Mesh(_) => 10,
            Self::ShapeNode(_) => 11,
            Self::ClipNode(_) => 12,
            Self::EntityNode(_) => 13,
            Self::OpacityNode(_) => 14,
            Self::Material(_) => 15,
            Self::Compositor(_) => 16,
            Self::DisplayCompositor(_) => 17,
            Self::LayerStack(_) => 19,
            Self::Layer(_) => 20,
            Self::Scene(_) => 21,
            Self::Camera(_) => 22,
            Self::StereoCamera(_) => 23,
            Self::Renderer(_) => 24,
            Self::AmbientLight(_) => 25,
            Self::DirectionalLight(_) => 26,
            Self::Variable(_) => 27,
            Self::PointLight(_) => 28,
            Self::View3(_) => 31,
            Self::ImagePipe2(_) => 32,
            Self::Image2(_) => 33,
            Self::Image3(_) => 34,
        }
    }

    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

impl fidl::Standalone for ResourceArgs {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub enum Value {
    Vector1(f32),
    Vector2(Vec2),
    Vector3(Vec3),
    Vector4(Vec4),
    Matrix4x4(Mat4),
    ColorRgba(ColorRgba),
    ColorRgb(ColorRgb),
    /// Degrees of counter-clockwise rotation in the XY plane.
    Degrees(f32),
    Quaternion(Quaternion),
    Transform(FactoredTransform),
    /// ID of a value-producing resource (an animation or an expression).
    /// The type of this value matches the type produced by the named resource.
    VariableId(u32),
}

impl Value {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Vector1(_) => 1,
            Self::Vector2(_) => 2,
            Self::Vector3(_) => 3,
            Self::Vector4(_) => 4,
            Self::Matrix4x4(_) => 5,
            Self::ColorRgba(_) => 6,
            Self::ColorRgb(_) => 7,
            Self::Degrees(_) => 8,
            Self::Quaternion(_) => 9,
            Self::Transform(_) => 10,
            Self::VariableId(_) => 11,
        }
    }

    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

impl fidl::Persistable for Value {}

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

impl fidl::endpoints::ProtocolMarker for SnapshotCallbackDeprecatedMarker {
    type Proxy = SnapshotCallbackDeprecatedProxy;
    type RequestStream = SnapshotCallbackDeprecatedRequestStream;

    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SnapshotCallbackDeprecatedSynchronousProxy;

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

pub trait SnapshotCallbackDeprecatedProxyInterface: Send + Sync {
    fn r#on_data(&self, data: fidl_fuchsia_mem::Buffer) -> Result<(), fidl::Error>;
}

#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SnapshotCallbackDeprecatedSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SnapshotCallbackDeprecatedSynchronousProxy {
    type Proxy = SnapshotCallbackDeprecatedProxy;
    type Protocol = SnapshotCallbackDeprecatedMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

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

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl SnapshotCallbackDeprecatedSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <SnapshotCallbackDeprecatedMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

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

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

    pub fn r#on_data(&self, mut data: fidl_fuchsia_mem::Buffer) -> Result<(), fidl::Error> {
        self.client.send::<SnapshotCallbackDeprecatedOnDataRequest>(
            (&mut data,),
            0x11d1a93b419b7d9f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct SnapshotCallbackDeprecatedProxy {
    client: fidl::client::Client,
}

impl fidl::endpoints::Proxy for SnapshotCallbackDeprecatedProxy {
    type Protocol = SnapshotCallbackDeprecatedMarker;

    fn from_channel(inner: fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl SnapshotCallbackDeprecatedProxy {
    /// Create a new Proxy for fuchsia.ui.gfx/SnapshotCallbackDEPRECATED.
    pub fn new(channel: fidl::AsyncChannel) -> Self {
        let protocol_name =
            <SnapshotCallbackDeprecatedMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> SnapshotCallbackDeprecatedEventStream {
        SnapshotCallbackDeprecatedEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#on_data(&self, mut data: fidl_fuchsia_mem::Buffer) -> Result<(), fidl::Error> {
        SnapshotCallbackDeprecatedProxyInterface::r#on_data(self, data)
    }
}

impl SnapshotCallbackDeprecatedProxyInterface for SnapshotCallbackDeprecatedProxy {
    fn r#on_data(&self, mut data: fidl_fuchsia_mem::Buffer) -> Result<(), fidl::Error> {
        self.client.send::<SnapshotCallbackDeprecatedOnDataRequest>(
            (&mut data,),
            0x11d1a93b419b7d9f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct SnapshotCallbackDeprecatedEventStream {
    event_receiver: fidl::client::EventReceiver,
}

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

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

impl futures::Stream for SnapshotCallbackDeprecatedEventStream {
    type Item = Result<SnapshotCallbackDeprecatedEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(SnapshotCallbackDeprecatedEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

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

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

/// A Stream of incoming requests for fuchsia.ui.gfx/SnapshotCallbackDEPRECATED.
pub struct SnapshotCallbackDeprecatedRequestStream {
    inner: std::sync::Arc<fidl::ServeInner>,
    is_terminated: bool,
}

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

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

impl fidl::endpoints::RequestStream for SnapshotCallbackDeprecatedRequestStream {
    type Protocol = SnapshotCallbackDeprecatedMarker;
    type ControlHandle = SnapshotCallbackDeprecatedControlHandle;

    fn from_channel(channel: fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        SnapshotCallbackDeprecatedControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(self) -> (::std::sync::Arc<fidl::ServeInner>, bool) {
        (self.inner, self.is_terminated)
    }

    fn from_inner(inner: std::sync::Arc<fidl::ServeInner>, is_terminated: bool) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for SnapshotCallbackDeprecatedRequestStream {
    type Item = Result<SnapshotCallbackDeprecatedRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled SnapshotCallbackDeprecatedRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf(|bytes, handles| {
            match this.inner.channel().read_etc(cx, bytes, handles) {
                std::task::Poll::Ready(Ok(())) => {}
                std::task::Poll::Pending => return std::task::Poll::Pending,
                std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                    this.is_terminated = true;
                    return std::task::Poll::Ready(None);
                }
                std::task::Poll::Ready(Err(e)) => {
                    return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(e))))
                }
            }

            // A message has been received from the channel
            let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

            std::task::Poll::Ready(Some(match header.ordinal {
                0x11d1a93b419b7d9f => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(SnapshotCallbackDeprecatedOnDataRequest);
                    fidl::encoding::Decoder::decode_into::<SnapshotCallbackDeprecatedOnDataRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SnapshotCallbackDeprecatedControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SnapshotCallbackDeprecatedRequest::OnData {data: req.data,

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

#[derive(Debug)]
pub enum SnapshotCallbackDeprecatedRequest {
    OnData {
        data: fidl_fuchsia_mem::Buffer,
        control_handle: SnapshotCallbackDeprecatedControlHandle,
    },
}

impl SnapshotCallbackDeprecatedRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_data(
        self,
    ) -> Option<(fidl_fuchsia_mem::Buffer, SnapshotCallbackDeprecatedControlHandle)> {
        if let SnapshotCallbackDeprecatedRequest::OnData { data, control_handle } = self {
            Some((data, control_handle))
        } else {
            None
        }
    }

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

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

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

    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }

    fn on_closed<'a>(&'a self) -> fidl::OnSignals<'a> {
        self.inner.channel().on_closed()
    }
}

impl SnapshotCallbackDeprecatedControlHandle {}

mod internal {
    use super::*;
    unsafe impl fidl::encoding::TypeMarker for HitTestBehavior {
        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 HitTestBehavior {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            *value
        }
    }

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

    impl fidl::encoding::Decode<Self> for HitTestBehavior {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::KDefault
        }

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

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

    impl fidl::encoding::Decode<Self> for ImportSpec {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Node
        }

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

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

    impl fidl::encoding::Decode<Self> for MeshIndexFormat {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::KUint16
        }

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

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

    impl fidl::encoding::Decode<Self> for RenderFrequency {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::WhenRequested
        }

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

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

    impl fidl::encoding::Decode<Self> for ShadowTechnique {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Unshadowed
        }

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

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

    impl fidl::encoding::Decode<Self> for ValueType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::KNone
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            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 AddChildCmd {
        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
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    unsafe impl fidl::encoding::TypeMarker for AmbientLightArgs {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for AmbientLightArgs {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for AmbientLightArgs {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { dummy: fidl::new_empty!(u32) }
        }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            88
        }
    }
    impl fidl::encoding::ValueTypeMarker for BindMeshBuffersCmd {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<BindMeshBuffersCmd> for &BindMeshBuffersCmd {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BindMeshBuffersCmd>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BindMeshBuffersCmd>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.mesh_id),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.index_buffer_id),
                    <MeshIndexFormat as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.index_format,
                    ),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.index_offset),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.index_count),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.vertex_buffer_id),
                    <MeshVertexFormat as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.vertex_format,
                    ),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.vertex_offset),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.vertex_count),
                    <BoundingBox as fidl::encoding::ValueTypeMarker>::borrow(&self.bounding_box),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u32>,
            T1: fidl::encoding::Encode<u32>,
            T2: fidl::encoding::Encode<MeshIndexFormat>,
            T3: fidl::encoding::Encode<u64>,
            T4: fidl::encoding::Encode<u32>,
            T5: fidl::encoding::Encode<u32>,
            T6: fidl::encoding::Encode<MeshVertexFormat>,
            T7: fidl::encoding::Encode<u64>,
            T8: fidl::encoding::Encode<u32>,
            T9: fidl::encoding::Encode<BoundingBox>,
        > fidl::encoding::Encode<BindMeshBuffersCmd> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BindMeshBuffersCmd>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(80);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 16, depth)?;
            self.4.encode(encoder, offset + 24, depth)?;
            self.5.encode(encoder, offset + 28, depth)?;
            self.6.encode(encoder, offset + 32, depth)?;
            self.7.encode(encoder, offset + 48, depth)?;
            self.8.encode(encoder, offset + 56, depth)?;
            self.9.encode(encoder, offset + 60, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for BindMeshBuffersCmd {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                mesh_id: fidl::new_empty!(u32),
                index_buffer_id: fidl::new_empty!(u32),
                index_format: fidl::new_empty!(MeshIndexFormat),
                index_offset: fidl::new_empty!(u64),
                index_count: fidl::new_empty!(u32),
                vertex_buffer_id: fidl::new_empty!(u32),
                vertex_format: fidl::new_empty!(MeshVertexFormat),
                vertex_offset: fidl::new_empty!(u64),
                vertex_count: fidl::new_empty!(u32),
                bounding_box: fidl::new_empty!(BoundingBox),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
            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 + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(80) };
            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 + 80 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(u32, &mut self.mesh_id, decoder, offset + 0, _depth)?;
            fidl::decode!(u32, &mut self.index_buffer_id, decoder, offset + 4, _depth)?;
            fidl::decode!(MeshIndexFormat, &mut self.index_format, decoder, offset + 8, _depth)?;
            fidl::decode!(u64, &mut self.index_offset, decoder, offset + 16, _depth)?;
            fidl::decode!(u32, &mut self.index_count, decoder, offset + 24, _depth)?;
            fidl::decode!(u32, &mut self.vertex_buffer_id, decoder, offset + 28, _depth)?;
            fidl::decode!(MeshVertexFormat, &mut self.vertex_format, decoder, offset + 32, _depth)?;
            fidl::decode!(u64, &mut self.vertex_offset, decoder, offset + 48, _depth)?;
            fidl::decode!(u32, &mut self.vertex_count, decoder, offset + 56, _depth)?;
            fidl::decode!(BoundingBox, &mut self.bounding_box, decoder, offset + 60, _depth)?;
            Ok(())
        }
    }

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }
    impl fidl::encoding::ValueTypeMarker for BoundingBox {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<BoundingBox> for &BoundingBox {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BoundingBox>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BoundingBox>::encode(
                (
                    <Vec3 as fidl::encoding::ValueTypeMarker>::borrow(&self.min),
                    <Vec3 as fidl::encoding::ValueTypeMarker>::borrow(&self.max),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<Vec3>, T1: fidl::encoding::Encode<Vec3>>
        fidl::encoding::Encode<BoundingBox> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BoundingBox>(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 + 12, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for BoundingBox {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { min: fidl::new_empty!(Vec3), max: fidl::new_empty!(Vec3) }
        }

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

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

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

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

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

    unsafe impl fidl::encoding::Encode<BufferArgs> for &BufferArgs {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BufferArgs>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut BufferArgs).write_unaligned((self as *const BufferArgs).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u32>,
            T1: fidl::encoding::Encode<u32>,
            T2: fidl::encoding::Encode<u32>,
        > fidl::encoding::Encode<BufferArgs> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BufferArgs>(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)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for BufferArgs {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                memory_id: fidl::new_empty!(u32),
                memory_offset: fidl::new_empty!(u32),
                num_bytes: fidl::new_empty!(u32),
            }
        }

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

    unsafe impl fidl::encoding::TypeMarker for CameraArgs {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for CameraArgs {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for CameraArgs {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { scene_id: fidl::new_empty!(u32) }
        }

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

    unsafe impl fidl::encoding::TypeMarker for CircleArgs {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for CircleArgs {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for CircleArgs {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { radius: fidl::new_empty!(Value) }
        }

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

    unsafe impl fidl::encoding::TypeMarker for ClipNodeArgs {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for ClipNodeArgs {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for ClipNodeArgs {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { unused: fidl::new_empty!(u32) }
        }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            12
        }
    }
    impl fidl::encoding::ValueTypeMarker for ColorRgb {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<ColorRgb> for &ColorRgb {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ColorRgb>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ColorRgb>::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),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<f32>,
            T1: fidl::encoding::Encode<f32>,
            T2: fidl::encoding::Encode<f32>,
        > fidl::encoding::Encode<ColorRgb> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ColorRgb>(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)?;
            Ok(())
        }
    }

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

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

    unsafe impl fidl::encoding::TypeMarker for ColorRgbValue {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for ColorRgbValue {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<ColorRgbValue> for &ColorRgbValue {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ColorRgbValue>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ColorRgbValue>::encode(
                (
                    <ColorRgb as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.variable_id),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<ColorRgb>, T1: fidl::encoding::Encode<u32>>
        fidl::encoding::Encode<ColorRgbValue> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ColorRgbValue>(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 + 12, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for ColorRgbValue {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { value: fidl::new_empty!(ColorRgb), variable_id: fidl::new_empty!(u32) }
        }

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

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

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

        #[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
        }
    }
    impl fidl::encoding::ValueTypeMarker for ColorRgba {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<ColorRgba> for &ColorRgba {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ColorRgba>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut ColorRgba).write_unaligned((self as *const ColorRgba).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u8>,
            T1: fidl::encoding::Encode<u8>,
            T2: fidl::encoding::Encode<u8>,
            T3: fidl::encoding::Encode<u8>,
        > fidl::encoding::Encode<ColorRgba> for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            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 + 1, depth)?;
            self.2.encode(encoder, offset + 2, depth)?;
            self.3.encode(encoder, offset + 3, depth)?;
            Ok(())
        }
    }

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

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

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

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

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

    impl fidl::encoding::Decode<Self> for ColorRgbaValue {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { value: fidl::new_empty!(ColorRgba), variable_id: fidl::new_empty!(u32) }
        }

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

    unsafe impl fidl::encoding::TypeMarker for CompositorArgs {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for CompositorArgs {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for CompositorArgs {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { dummy: fidl::new_empty!(u32) }
        }

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

    unsafe impl fidl::encoding::TypeMarker for CreateResourceCmd {
        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
        }
    }
    impl fidl::encoding::ResourceTypeMarker for CreateResourceCmd {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for CreateResourceCmd {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { id: fidl::new_empty!(u32), resource: fidl::new_empty!(ResourceArgs) }
        }

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

    unsafe impl fidl::encoding::TypeMarker for DetachChildrenCmd {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for DetachChildrenCmd {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for DetachChildrenCmd {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { node_id: fidl::new_empty!(u32) }
        }

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

    unsafe impl fidl::encoding::TypeMarker for DetachCmd {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for DetachCmd {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for DetachCmd {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { id: fidl::new_empty!(u32) }
        }

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

    unsafe impl fidl::encoding::TypeMarker for DetachLightCmd {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for DetachLightCmd {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for DetachLightCmd {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { light_id: fidl::new_empty!(u32) }
        }

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

    unsafe impl fidl::encoding::TypeMarker for DetachLightsCmd {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for DetachLightsCmd {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for DetachLightsCmd {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { scene_id: fidl::new_empty!(u32) }
        }

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

    unsafe impl fidl::encoding::TypeMarker for DirectionalLightArgs {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for DirectionalLightArgs {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for DirectionalLightArgs {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { dummy: fidl::new_empty!(u32) }
        }

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

    unsafe impl fidl::encoding::TypeMarker for DisplayCompositorArgs {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for DisplayCompositorArgs {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for DisplayCompositorArgs {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { dummy: fidl::new_empty!(u32) }
        }

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

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

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

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

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

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

    unsafe impl fidl::encoding::TypeMarker for EntityNodeArgs {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for EntityNodeArgs {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for EntityNodeArgs {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { unused: fidl::new_empty!(u32) }
        }

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

    unsafe impl fidl::encoding::TypeMarker for ExportResourceCmdDeprecated {
        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
        }
    }
    impl fidl::encoding::ResourceTypeMarker for ExportResourceCmdDeprecated {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

    unsafe impl fidl::encoding::TypeMarker for ExportToken {
        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
        }
    }
    impl fidl::encoding::ResourceTypeMarker for ExportToken {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            52
        }
    }
    impl fidl::encoding::ValueTypeMarker for FactoredTransform {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<FactoredTransform> for &FactoredTransform {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FactoredTransform>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FactoredTransform>::encode(
                (
                    <Vec3 as fidl::encoding::ValueTypeMarker>::borrow(&self.translation),
                    <Vec3 as fidl::encoding::ValueTypeMarker>::borrow(&self.scale),
                    <Vec3 as fidl::encoding::ValueTypeMarker>::borrow(&self.anchor),
                    <Quaternion as fidl::encoding::ValueTypeMarker>::borrow(&self.rotation),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<Vec3>,
            T1: fidl::encoding::Encode<Vec3>,
            T2: fidl::encoding::Encode<Vec3>,
            T3: fidl::encoding::Encode<Quaternion>,
        > fidl::encoding::Encode<FactoredTransform> for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FactoredTransform>(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 + 12, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            self.3.encode(encoder, offset + 36, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for FactoredTransform {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                translation: fidl::new_empty!(Vec3),
                scale: fidl::new_empty!(Vec3),
                anchor: fidl::new_empty!(Vec3),
                rotation: fidl::new_empty!(Quaternion),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(Vec3, &mut self.translation, decoder, offset + 0, _depth)?;
            fidl::decode!(Vec3, &mut self.scale, decoder, offset + 12, _depth)?;
            fidl::decode!(Vec3, &mut self.anchor, decoder, offset + 24, _depth)?;
            fidl::decode!(Quaternion, &mut self.rotation, decoder, offset + 36, _depth)?;
            Ok(())
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FloatValue {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for FloatValue {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<FloatValue> for &FloatValue {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FloatValue>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FloatValue>::encode(
                (
                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.variable_id),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<f32>, T1: fidl::encoding::Encode<u32>>
        fidl::encoding::Encode<FloatValue> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FloatValue>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for FloatValue {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { value: fidl::new_empty!(f32), variable_id: fidl::new_empty!(u32) }
        }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            40
        }
    }
    impl fidl::encoding::ValueTypeMarker for ImageArgs {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<ImageArgs> for &ImageArgs {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageArgs>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ImageArgs>::encode(
                (
                    <fidl_fuchsia_images::ImageInfo as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.info,
                    ),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.memory_id),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.memory_offset),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<fidl_fuchsia_images::ImageInfo>,
            T1: fidl::encoding::Encode<u32>,
            T2: fidl::encoding::Encode<u32>,
        > fidl::encoding::Encode<ImageArgs> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageArgs>(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 + 32, depth)?;
            self.2.encode(encoder, offset + 36, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for ImageArgs {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                info: fidl::new_empty!(fidl_fuchsia_images::ImageInfo),
                memory_id: fidl::new_empty!(u32),
                memory_offset: fidl::new_empty!(u32),
            }
        }

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

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

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

    unsafe impl fidl::encoding::Encode<ImageArgs2> for &ImageArgs2 {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageArgs2>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut ImageArgs2).write_unaligned((self as *const ImageArgs2).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u32>,
            T1: fidl::encoding::Encode<u32>,
            T2: fidl::encoding::Encode<u32>,
            T3: fidl::encoding::Encode<u32>,
        > fidl::encoding::Encode<ImageArgs2> for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageArgs2>(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 fidl::encoding::Decode<Self> for ImageArgs2 {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                width: fidl::new_empty!(u32),
                height: fidl::new_empty!(u32),
                buffer_collection_id: fidl::new_empty!(u32),
                buffer_collection_index: fidl::new_empty!(u32),
            }
        }

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

    unsafe impl fidl::encoding::TypeMarker for ImageArgs3 {
        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
        }
    }
    impl fidl::encoding::ResourceTypeMarker for ImageArgs3 {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<ImageArgs3> for &mut ImageArgs3 {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageArgs3>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ImageArgs3>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.width),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.height),
                    <fidl_fuchsia_ui_composition::BufferCollectionImportToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.import_token),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.buffer_collection_index),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u32>,
            T1: fidl::encoding::Encode<u32>,
            T2: fidl::encoding::Encode<fidl_fuchsia_ui_composition::BufferCollectionImportToken>,
            T3: fidl::encoding::Encode<u32>,
        > fidl::encoding::Encode<ImageArgs3> for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageArgs3>(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 fidl::encoding::Decode<Self> for ImageArgs3 {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                width: fidl::new_empty!(u32),
                height: fidl::new_empty!(u32),
                import_token: fidl::new_empty!(
                    fidl_fuchsia_ui_composition::BufferCollectionImportToken
                ),
                buffer_collection_index: fidl::new_empty!(u32),
            }
        }

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

    unsafe impl fidl::encoding::TypeMarker for ImagePipe2Args {
        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
        }
    }
    impl fidl::encoding::ResourceTypeMarker for ImagePipe2Args {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for ImagePipe2Args {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                image_pipe_request: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_images::ImagePipe2Marker>,
                    >
                ),
            }
        }

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

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

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

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            12
        }
    }
    impl fidl::encoding::ResourceTypeMarker for ImportResourceCmdDeprecated {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<ImportResourceCmdDeprecated>
        for &mut ImportResourceCmdDeprecated
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImportResourceCmdDeprecated>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ImportResourceCmdDeprecated>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
                    <fidl::encoding::HandleType<
                        fidl::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.token
                    ),
                    <ImportSpec as fidl::encoding::ValueTypeMarker>::borrow(&self.spec),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u32>,
            T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
            >,
            T2: fidl::encoding::Encode<ImportSpec>,
        > fidl::encoding::Encode<ImportResourceCmdDeprecated> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImportResourceCmdDeprecated>(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)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self> for ImportResourceCmdDeprecated {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(u32),
                token: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>),
                spec: fidl::new_empty!(ImportSpec),
            }
        }

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

    unsafe impl fidl::encoding::TypeMarker for ImportToken {
        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
        }
    }
    impl fidl::encoding::ResourceTypeMarker for ImportToken {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

    unsafe impl fidl::encoding::TypeMarker for ImportUnboundEvent {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for ImportUnboundEvent {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

    impl fidl::encoding::Decode<Self> for ImportUnboundEvent {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { resource_id: fidl::new_empty!(u32) }
        }

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

    unsafe impl fidl::encoding::TypeMarker for LayerArgs {
        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
        }
    }
    impl fidl::encoding::ValueTypeMarker for LayerArgs {
        type Borrowed<'a> = &'a Self;
        fn borrow<'a>(
            value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::Encode<LayerArgs> for &LayerArgs {