fidl_fuchsia_ui_gfx/

fidl_fuchsia_ui_gfx.rs

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

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

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

/// 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<fidl::encoding::DefaultFuchsiaResourceDialect> for CreateResourceCmd {}

/// 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<fidl::encoding::DefaultFuchsiaResourceDialect>
    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<fidl::encoding::DefaultFuchsiaResourceDialect> for ExportToken {}

/// 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<fidl::encoding::DefaultFuchsiaResourceDialect> 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<fidl::encoding::DefaultFuchsiaResourceDialect> 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<fidl::encoding::DefaultFuchsiaResourceDialect>
    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<fidl::encoding::DefaultFuchsiaResourceDialect> for ImportToken {}

/// `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<fidl::encoding::DefaultFuchsiaResourceDialect> for MemoryArgs {}

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

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

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

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

/// 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<fidl::encoding::DefaultFuchsiaResourceDialect> 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<fidl::encoding::DefaultFuchsiaResourceDialect> for ViewArgs3 {}

/// 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<fidl::encoding::DefaultFuchsiaResourceDialect> for ViewHolderArgs {}

/// 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,
        }
    }
}

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

/// 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,
        }
    }
}

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

#[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::MonotonicInstant,
    ) -> 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(),
        )
    }
}

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

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

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

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

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

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<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

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::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    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<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

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

impl futures::Stream for 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::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

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

                std::task::Poll::Ready(Some(match header.ordinal {
                0x11d1a93b419b7d9f => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(SnapshotCallbackDeprecatedOnDataRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::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<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

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(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

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

impl SnapshotCallbackDeprecatedControlHandle {}

mod internal {
    use super::*;

    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::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
        }
    }

    unsafe impl
        fidl::encoding::Encode<CreateResourceCmd, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut CreateResourceCmd
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CreateResourceCmd>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CreateResourceCmd, fidl::encoding::DefaultFuchsiaResourceDialect>::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, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<ResourceArgs, fidl::encoding::DefaultFuchsiaResourceDialect>,
    > fidl::encoding::Encode<CreateResourceCmd, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CreateResourceCmd
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                resource: fidl::new_empty!(
                    ResourceArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    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::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
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ExportResourceCmdDeprecated,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ExportResourceCmdDeprecated
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ExportResourceCmdDeprecated>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ExportResourceCmdDeprecated,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::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, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ExportResourceCmdDeprecated,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ExportResourceCmdDeprecated
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                token: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    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::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
        }
    }

    unsafe impl fidl::encoding::Encode<ExportToken, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut ExportToken
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ExportToken>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ExportToken, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<ExportToken, fidl::encoding::DefaultFuchsiaResourceDialect> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect> for ExportToken {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                value: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for 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::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
        }
    }

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

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

    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::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
        }
    }

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

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

    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::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
        }
    }

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

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

    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::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
        }
    }

    unsafe impl fidl::encoding::Encode<ImportToken, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut ImportToken
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImportToken>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ImportToken, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<ImportToken, fidl::encoding::DefaultFuchsiaResourceDialect> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<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, fidl::encoding::DefaultFuchsiaResourceDialect> for ImportToken {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                value: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for MemoryArgs {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

    unsafe impl fidl::encoding::Encode<MemoryArgs, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut MemoryArgs
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MemoryArgs>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<MemoryArgs, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.vmo),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.allocation_size),
                    <fidl_fuchsia_images::MemoryType as fidl::encoding::ValueTypeMarker>::borrow(&self.memory_type),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Vmo,
                    { fidl::ObjectType::VMO.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<
                fidl_fuchsia_images::MemoryType,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<MemoryArgs, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MemoryArgs>(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);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for MemoryArgs {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vmo: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                allocation_size: fidl::new_empty!(
                    u64,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                memory_type: fidl::new_empty!(
                    fidl_fuchsia_images::MemoryType,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            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 + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmo, decoder, offset + 0, _depth)?;
            fidl::decode!(
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.allocation_size,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_images::MemoryType,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.memory_type,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for SnapshotCallbackDeprecatedOnDataRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for SnapshotCallbackDeprecatedOnDataRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                data: fidl::new_empty!(
                    fidl_fuchsia_mem::Buffer,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for TakeSnapshotCmdDeprecated {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TakeSnapshotCmdDeprecated
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                node_id: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                callback: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<SnapshotCallbackDeprecatedMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for ViewArgs {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for ViewArgs {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                token: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewToken,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                debug_name: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for ViewArgs3 {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for ViewArgs3 {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                token: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewToken,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                control_ref: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewRefControl,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                view_ref: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewRef,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                debug_name: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for ViewHolderArgs {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

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

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ViewHolderArgs
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                token: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewHolderToken,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                debug_name: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for Command {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

    unsafe impl fidl::encoding::Encode<Command, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut Command
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Command>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            Command::CreateResource(ref mut val) => {
                fidl::encoding::encode_in_envelope::<CreateResourceCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <CreateResourceCmd as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::ReleaseResource(ref val) => {
                fidl::encoding::encode_in_envelope::<ReleaseResourceCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <ReleaseResourceCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::ExportResource(ref mut val) => {
                fidl::encoding::encode_in_envelope::<ExportResourceCmdDeprecated, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <ExportResourceCmdDeprecated as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::ImportResource(ref mut val) => {
                fidl::encoding::encode_in_envelope::<ImportResourceCmdDeprecated, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <ImportResourceCmdDeprecated as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetTag(ref val) => {
                fidl::encoding::encode_in_envelope::<SetTagCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetTagCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::Detach(ref val) => {
                fidl::encoding::encode_in_envelope::<DetachCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <DetachCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetTranslation(ref val) => {
                fidl::encoding::encode_in_envelope::<SetTranslationCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetTranslationCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetScale(ref val) => {
                fidl::encoding::encode_in_envelope::<SetScaleCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetScaleCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetRotation(ref val) => {
                fidl::encoding::encode_in_envelope::<SetRotationCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetRotationCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetAnchor(ref val) => {
                fidl::encoding::encode_in_envelope::<SetAnchorCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetAnchorCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetSize(ref val) => {
                fidl::encoding::encode_in_envelope::<SetSizeCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetSizeCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetOpacity(ref val) => {
                fidl::encoding::encode_in_envelope::<SetOpacityCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetOpacityCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SendSizeChangeHintHack(ref val) => {
                fidl::encoding::encode_in_envelope::<SendSizeChangeHintCmdHack, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SendSizeChangeHintCmdHack as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::AddChild(ref val) => {
                fidl::encoding::encode_in_envelope::<AddChildCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <AddChildCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::AddPart(ref val) => {
                fidl::encoding::encode_in_envelope::<AddPartCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <AddPartCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::DetachChildren(ref val) => {
                fidl::encoding::encode_in_envelope::<DetachChildrenCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <DetachChildrenCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetShape(ref val) => {
                fidl::encoding::encode_in_envelope::<SetShapeCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetShapeCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetMaterial(ref val) => {
                fidl::encoding::encode_in_envelope::<SetMaterialCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetMaterialCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetClip(ref val) => {
                fidl::encoding::encode_in_envelope::<SetClipCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetClipCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetHitTestBehavior(ref val) => {
                fidl::encoding::encode_in_envelope::<SetHitTestBehaviorCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetHitTestBehaviorCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetViewProperties(ref val) => {
                fidl::encoding::encode_in_envelope::<SetViewPropertiesCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetViewPropertiesCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::TakeSnapshotCmd(ref mut val) => {
                fidl::encoding::encode_in_envelope::<TakeSnapshotCmdDeprecated, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <TakeSnapshotCmdDeprecated as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetCamera(ref val) => {
                fidl::encoding::encode_in_envelope::<SetCameraCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetCameraCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetCameraTransform(ref val) => {
                fidl::encoding::encode_in_envelope::<SetCameraTransformCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetCameraTransformCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetCameraProjection(ref val) => {
                fidl::encoding::encode_in_envelope::<SetCameraProjectionCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetCameraProjectionCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetStereoCameraProjection(ref val) => {
                fidl::encoding::encode_in_envelope::<SetStereoCameraProjectionCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetStereoCameraProjectionCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetCameraPoseBuffer(ref val) => {
                fidl::encoding::encode_in_envelope::<SetCameraPoseBufferCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetCameraPoseBufferCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetLightColor(ref val) => {
                fidl::encoding::encode_in_envelope::<SetLightColorCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetLightColorCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetLightDirection(ref val) => {
                fidl::encoding::encode_in_envelope::<SetLightDirectionCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetLightDirectionCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::AddLight(ref val) => {
                fidl::encoding::encode_in_envelope::<AddLightCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <AddLightCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::DetachLight(ref val) => {
                fidl::encoding::encode_in_envelope::<DetachLightCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <DetachLightCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::DetachLights(ref val) => {
                fidl::encoding::encode_in_envelope::<DetachLightsCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <DetachLightsCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetTexture(ref val) => {
                fidl::encoding::encode_in_envelope::<SetTextureCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetTextureCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetColor(ref val) => {
                fidl::encoding::encode_in_envelope::<SetColorCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetColorCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::BindMeshBuffers(ref val) => {
                fidl::encoding::encode_in_envelope::<BindMeshBuffersCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <BindMeshBuffersCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::AddLayer(ref val) => {
                fidl::encoding::encode_in_envelope::<AddLayerCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <AddLayerCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::RemoveLayer(ref val) => {
                fidl::encoding::encode_in_envelope::<RemoveLayerCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <RemoveLayerCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::RemoveAllLayers(ref val) => {
                fidl::encoding::encode_in_envelope::<RemoveAllLayersCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <RemoveAllLayersCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetLayerStack(ref val) => {
                fidl::encoding::encode_in_envelope::<SetLayerStackCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetLayerStackCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetRenderer(ref val) => {
                fidl::encoding::encode_in_envelope::<SetRendererCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetRendererCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetRendererParam(ref val) => {
                fidl::encoding::encode_in_envelope::<SetRendererParamCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetRendererParamCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetEventMask(ref val) => {
                fidl::encoding::encode_in_envelope::<SetEventMaskCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetEventMaskCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetLabel(ref val) => {
                fidl::encoding::encode_in_envelope::<SetLabelCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetLabelCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetDisableClipping(ref val) => {
                fidl::encoding::encode_in_envelope::<SetDisableClippingCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetDisableClippingCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetImportFocus(ref val) => {
                fidl::encoding::encode_in_envelope::<SetImportFocusCmdDeprecated, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetImportFocusCmdDeprecated as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetClipPlanes(ref val) => {
                fidl::encoding::encode_in_envelope::<SetClipPlanesCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetClipPlanesCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetPointLightPosition(ref val) => {
                fidl::encoding::encode_in_envelope::<SetPointLightPositionCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetPointLightPositionCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetPointLightFalloff(ref val) => {
                fidl::encoding::encode_in_envelope::<SetPointLightFalloffCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetPointLightFalloffCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::Scene_AddAmbientLight(ref val) => {
                fidl::encoding::encode_in_envelope::<SceneAddAmbientLightCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SceneAddAmbientLightCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::Scene_AddDirectionalLight(ref val) => {
                fidl::encoding::encode_in_envelope::<SceneAddDirectionalLightCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SceneAddDirectionalLightCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::Scene_AddPointLight(ref val) => {
                fidl::encoding::encode_in_envelope::<SceneAddPointLightCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SceneAddPointLightCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetDisplayColorConversion(ref val) => {
                fidl::encoding::encode_in_envelope::<SetDisplayColorConversionCmdHack, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetDisplayColorConversionCmdHack as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetDisplayRotation(ref val) => {
                fidl::encoding::encode_in_envelope::<SetDisplayRotationCmdHack, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetDisplayRotationCmdHack as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetEnableViewDebugBounds(ref val) => {
                fidl::encoding::encode_in_envelope::<SetEnableDebugViewBoundsCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetEnableDebugViewBoundsCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetViewHolderBoundsColor(ref val) => {
                fidl::encoding::encode_in_envelope::<SetViewHolderBoundsColorCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetViewHolderBoundsColorCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetCameraClipSpaceTransform(ref val) => {
                fidl::encoding::encode_in_envelope::<SetCameraClipSpaceTransformCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetCameraClipSpaceTransformCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetDisplayMinimumRgb(ref val) => {
                fidl::encoding::encode_in_envelope::<SetDisplayMinimumRgbCmdHack, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetDisplayMinimumRgbCmdHack as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Command::SetSemanticVisibility(ref val) => {
                fidl::encoding::encode_in_envelope::<SetSemanticVisibilityCmd, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <SetSemanticVisibilityCmd as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
        }
        }
    }

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

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

            let member_inline_size = match ordinal {
                1 => {
                    <CreateResourceCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
                }
                2 => {
                    <ReleaseResourceCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
                }
                3 => <ExportResourceCmdDeprecated as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                4 => <ImportResourceCmdDeprecated as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                5 => <SetTagCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                6 => <DetachCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                7 => {
                    <SetTranslationCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
                }
                8 => <SetScaleCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                9 => <SetRotationCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                10 => <SetAnchorCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                11 => <SetSizeCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                12 => <SetOpacityCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                13 => <SendSizeChangeHintCmdHack as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                14 => <AddChildCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                15 => <AddPartCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                16 => {
                    <DetachChildrenCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
                }
                17 => <SetShapeCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                18 => <SetMaterialCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                19 => <SetClipCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                20 => <SetHitTestBehaviorCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                21 => <SetViewPropertiesCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                22 => <TakeSnapshotCmdDeprecated as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                23 => <SetCameraCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                24 => <SetCameraTransformCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                25 => <SetCameraProjectionCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                26 => <SetStereoCameraProjectionCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                27 => <SetCameraPoseBufferCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                28 => {
                    <SetLightColorCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
                }
                29 => <SetLightDirectionCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                30 => <AddLightCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                31 => <DetachLightCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                32 => <DetachLightsCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                33 => <SetTextureCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                34 => <SetColorCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                35 => {
                    <BindMeshBuffersCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
                }
                36 => <AddLayerCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                37 => <RemoveLayerCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                38 => {
                    <RemoveAllLayersCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
                }
                39 => {
                    <SetLayerStackCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
                }
                40 => <SetRendererCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                41 => <SetRendererParamCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                42 => <SetEventMaskCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                43 => <SetLabelCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                44 => <SetDisableClippingCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                45 => <SetImportFocusCmdDeprecated as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                46 => {
                    <SetClipPlanesCmd as fidl::encoding::TypeMarker>::inline_size(decoder.context)
                }
                47 => <SetPointLightPositionCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                48 => <SetPointLightFalloffCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                49 => <SceneAddAmbientLightCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                50 => <SceneAddDirectionalLightCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                51 => <SceneAddPointLightCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                52 => {
                    <SetDisplayColorConversionCmdHack as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    )
                }
                53 => <SetDisplayRotationCmdHack as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                54 => <SetEnableDebugViewBoundsCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                55 => <SetViewHolderBoundsColorCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                56 => <SetCameraClipSpaceTransformCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                57 => <SetDisplayMinimumRgbCmdHack as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                58 => <SetSemanticVisibilityCmd as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                _ => return Err(fidl::Error::UnknownUnionTag),
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::CreateResource(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::CreateResource(fidl::new_empty!(
                            CreateResourceCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::CreateResource(ref mut val) = self {
                        fidl::decode!(
                            CreateResourceCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::ReleaseResource(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::ReleaseResource(fidl::new_empty!(
                            ReleaseResourceCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::ReleaseResource(ref mut val) = self {
                        fidl::decode!(
                            ReleaseResourceCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::ExportResource(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::ExportResource(fidl::new_empty!(
                            ExportResourceCmdDeprecated,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::ExportResource(ref mut val) = self {
                        fidl::decode!(
                            ExportResourceCmdDeprecated,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                4 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::ImportResource(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::ImportResource(fidl::new_empty!(
                            ImportResourceCmdDeprecated,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::ImportResource(ref mut val) = self {
                        fidl::decode!(
                            ImportResourceCmdDeprecated,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                5 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetTag(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetTag(fidl::new_empty!(
                            SetTagCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetTag(ref mut val) = self {
                        fidl::decode!(
                            SetTagCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                6 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::Detach(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::Detach(fidl::new_empty!(
                            DetachCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::Detach(ref mut val) = self {
                        fidl::decode!(
                            DetachCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                7 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetTranslation(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetTranslation(fidl::new_empty!(
                            SetTranslationCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetTranslation(ref mut val) = self {
                        fidl::decode!(
                            SetTranslationCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                8 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetScale(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetScale(fidl::new_empty!(
                            SetScaleCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetScale(ref mut val) = self {
                        fidl::decode!(
                            SetScaleCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                9 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetRotation(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetRotation(fidl::new_empty!(
                            SetRotationCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetRotation(ref mut val) = self {
                        fidl::decode!(
                            SetRotationCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                10 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetAnchor(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetAnchor(fidl::new_empty!(
                            SetAnchorCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetAnchor(ref mut val) = self {
                        fidl::decode!(
                            SetAnchorCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                11 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetSize(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetSize(fidl::new_empty!(
                            SetSizeCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetSize(ref mut val) = self {
                        fidl::decode!(
                            SetSizeCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                12 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetOpacity(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetOpacity(fidl::new_empty!(
                            SetOpacityCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetOpacity(ref mut val) = self {
                        fidl::decode!(
                            SetOpacityCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                13 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SendSizeChangeHintHack(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SendSizeChangeHintHack(fidl::new_empty!(
                            SendSizeChangeHintCmdHack,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SendSizeChangeHintHack(ref mut val) = self {
                        fidl::decode!(
                            SendSizeChangeHintCmdHack,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                14 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::AddChild(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::AddChild(fidl::new_empty!(
                            AddChildCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::AddChild(ref mut val) = self {
                        fidl::decode!(
                            AddChildCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                15 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::AddPart(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::AddPart(fidl::new_empty!(
                            AddPartCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::AddPart(ref mut val) = self {
                        fidl::decode!(
                            AddPartCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                16 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::DetachChildren(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::DetachChildren(fidl::new_empty!(
                            DetachChildrenCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::DetachChildren(ref mut val) = self {
                        fidl::decode!(
                            DetachChildrenCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                17 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetShape(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetShape(fidl::new_empty!(
                            SetShapeCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetShape(ref mut val) = self {
                        fidl::decode!(
                            SetShapeCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                18 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetMaterial(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetMaterial(fidl::new_empty!(
                            SetMaterialCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetMaterial(ref mut val) = self {
                        fidl::decode!(
                            SetMaterialCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                19 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetClip(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetClip(fidl::new_empty!(
                            SetClipCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetClip(ref mut val) = self {
                        fidl::decode!(
                            SetClipCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                20 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetHitTestBehavior(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetHitTestBehavior(fidl::new_empty!(
                            SetHitTestBehaviorCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetHitTestBehavior(ref mut val) = self {
                        fidl::decode!(
                            SetHitTestBehaviorCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                21 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetViewProperties(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetViewProperties(fidl::new_empty!(
                            SetViewPropertiesCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetViewProperties(ref mut val) = self {
                        fidl::decode!(
                            SetViewPropertiesCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                22 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::TakeSnapshotCmd(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::TakeSnapshotCmd(fidl::new_empty!(
                            TakeSnapshotCmdDeprecated,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::TakeSnapshotCmd(ref mut val) = self {
                        fidl::decode!(
                            TakeSnapshotCmdDeprecated,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                23 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetCamera(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetCamera(fidl::new_empty!(
                            SetCameraCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetCamera(ref mut val) = self {
                        fidl::decode!(
                            SetCameraCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                24 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetCameraTransform(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetCameraTransform(fidl::new_empty!(
                            SetCameraTransformCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetCameraTransform(ref mut val) = self {
                        fidl::decode!(
                            SetCameraTransformCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                25 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetCameraProjection(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetCameraProjection(fidl::new_empty!(
                            SetCameraProjectionCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetCameraProjection(ref mut val) = self {
                        fidl::decode!(
                            SetCameraProjectionCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                26 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetStereoCameraProjection(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetStereoCameraProjection(fidl::new_empty!(
                            SetStereoCameraProjectionCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetStereoCameraProjection(ref mut val) = self {
                        fidl::decode!(
                            SetStereoCameraProjectionCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                27 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetCameraPoseBuffer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetCameraPoseBuffer(fidl::new_empty!(
                            SetCameraPoseBufferCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetCameraPoseBuffer(ref mut val) = self {
                        fidl::decode!(
                            SetCameraPoseBufferCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                28 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetLightColor(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetLightColor(fidl::new_empty!(
                            SetLightColorCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetLightColor(ref mut val) = self {
                        fidl::decode!(
                            SetLightColorCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                29 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetLightDirection(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetLightDirection(fidl::new_empty!(
                            SetLightDirectionCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetLightDirection(ref mut val) = self {
                        fidl::decode!(
                            SetLightDirectionCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                30 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::AddLight(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::AddLight(fidl::new_empty!(
                            AddLightCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::AddLight(ref mut val) = self {
                        fidl::decode!(
                            AddLightCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                31 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::DetachLight(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::DetachLight(fidl::new_empty!(
                            DetachLightCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::DetachLight(ref mut val) = self {
                        fidl::decode!(
                            DetachLightCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                32 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::DetachLights(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::DetachLights(fidl::new_empty!(
                            DetachLightsCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::DetachLights(ref mut val) = self {
                        fidl::decode!(
                            DetachLightsCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                33 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetTexture(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetTexture(fidl::new_empty!(
                            SetTextureCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetTexture(ref mut val) = self {
                        fidl::decode!(
                            SetTextureCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                34 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetColor(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetColor(fidl::new_empty!(
                            SetColorCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetColor(ref mut val) = self {
                        fidl::decode!(
                            SetColorCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                35 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::BindMeshBuffers(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::BindMeshBuffers(fidl::new_empty!(
                            BindMeshBuffersCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::BindMeshBuffers(ref mut val) = self {
                        fidl::decode!(
                            BindMeshBuffersCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                36 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::AddLayer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::AddLayer(fidl::new_empty!(
                            AddLayerCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::AddLayer(ref mut val) = self {
                        fidl::decode!(
                            AddLayerCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                37 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::RemoveLayer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::RemoveLayer(fidl::new_empty!(
                            RemoveLayerCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::RemoveLayer(ref mut val) = self {
                        fidl::decode!(
                            RemoveLayerCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                38 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::RemoveAllLayers(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::RemoveAllLayers(fidl::new_empty!(
                            RemoveAllLayersCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::RemoveAllLayers(ref mut val) = self {
                        fidl::decode!(
                            RemoveAllLayersCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                39 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetLayerStack(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetLayerStack(fidl::new_empty!(
                            SetLayerStackCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetLayerStack(ref mut val) = self {
                        fidl::decode!(
                            SetLayerStackCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                40 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetRenderer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetRenderer(fidl::new_empty!(
                            SetRendererCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetRenderer(ref mut val) = self {
                        fidl::decode!(
                            SetRendererCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                41 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetRendererParam(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetRendererParam(fidl::new_empty!(
                            SetRendererParamCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetRendererParam(ref mut val) = self {
                        fidl::decode!(
                            SetRendererParamCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                42 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetEventMask(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetEventMask(fidl::new_empty!(
                            SetEventMaskCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetEventMask(ref mut val) = self {
                        fidl::decode!(
                            SetEventMaskCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                43 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetLabel(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetLabel(fidl::new_empty!(
                            SetLabelCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetLabel(ref mut val) = self {
                        fidl::decode!(
                            SetLabelCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                44 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetDisableClipping(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetDisableClipping(fidl::new_empty!(
                            SetDisableClippingCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetDisableClipping(ref mut val) = self {
                        fidl::decode!(
                            SetDisableClippingCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                45 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetImportFocus(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetImportFocus(fidl::new_empty!(
                            SetImportFocusCmdDeprecated,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetImportFocus(ref mut val) = self {
                        fidl::decode!(
                            SetImportFocusCmdDeprecated,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                46 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetClipPlanes(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetClipPlanes(fidl::new_empty!(
                            SetClipPlanesCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetClipPlanes(ref mut val) = self {
                        fidl::decode!(
                            SetClipPlanesCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                47 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetPointLightPosition(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetPointLightPosition(fidl::new_empty!(
                            SetPointLightPositionCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetPointLightPosition(ref mut val) = self {
                        fidl::decode!(
                            SetPointLightPositionCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                48 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetPointLightFalloff(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetPointLightFalloff(fidl::new_empty!(
                            SetPointLightFalloffCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetPointLightFalloff(ref mut val) = self {
                        fidl::decode!(
                            SetPointLightFalloffCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                49 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::Scene_AddAmbientLight(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::Scene_AddAmbientLight(fidl::new_empty!(
                            SceneAddAmbientLightCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::Scene_AddAmbientLight(ref mut val) = self {
                        fidl::decode!(
                            SceneAddAmbientLightCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                50 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::Scene_AddDirectionalLight(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::Scene_AddDirectionalLight(fidl::new_empty!(
                            SceneAddDirectionalLightCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::Scene_AddDirectionalLight(ref mut val) = self {
                        fidl::decode!(
                            SceneAddDirectionalLightCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                51 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::Scene_AddPointLight(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::Scene_AddPointLight(fidl::new_empty!(
                            SceneAddPointLightCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::Scene_AddPointLight(ref mut val) = self {
                        fidl::decode!(
                            SceneAddPointLightCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                52 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetDisplayColorConversion(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetDisplayColorConversion(fidl::new_empty!(
                            SetDisplayColorConversionCmdHack,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetDisplayColorConversion(ref mut val) = self {
                        fidl::decode!(
                            SetDisplayColorConversionCmdHack,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                53 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetDisplayRotation(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetDisplayRotation(fidl::new_empty!(
                            SetDisplayRotationCmdHack,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetDisplayRotation(ref mut val) = self {
                        fidl::decode!(
                            SetDisplayRotationCmdHack,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                54 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetEnableViewDebugBounds(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetEnableViewDebugBounds(fidl::new_empty!(
                            SetEnableDebugViewBoundsCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetEnableViewDebugBounds(ref mut val) = self {
                        fidl::decode!(
                            SetEnableDebugViewBoundsCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                55 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetViewHolderBoundsColor(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetViewHolderBoundsColor(fidl::new_empty!(
                            SetViewHolderBoundsColorCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetViewHolderBoundsColor(ref mut val) = self {
                        fidl::decode!(
                            SetViewHolderBoundsColorCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                56 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetCameraClipSpaceTransform(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetCameraClipSpaceTransform(fidl::new_empty!(
                            SetCameraClipSpaceTransformCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetCameraClipSpaceTransform(ref mut val) = self {
                        fidl::decode!(
                            SetCameraClipSpaceTransformCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                57 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetDisplayMinimumRgb(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetDisplayMinimumRgb(fidl::new_empty!(
                            SetDisplayMinimumRgbCmdHack,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetDisplayMinimumRgb(ref mut val) = self {
                        fidl::decode!(
                            SetDisplayMinimumRgbCmdHack,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                58 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetSemanticVisibility(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Command::SetSemanticVisibility(fidl::new_empty!(
                            SetSemanticVisibilityCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Command::SetSemanticVisibility(ref mut val) = self {
                        fidl::decode!(
                            SetSemanticVisibilityCmd,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ResourceArgs {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

    unsafe impl fidl::encoding::Encode<ResourceArgs, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut ResourceArgs
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ResourceArgs>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                ResourceArgs::Memory(ref mut val) => fidl::encoding::encode_in_envelope::<
                    MemoryArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <MemoryArgs as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::Image(ref val) => fidl::encoding::encode_in_envelope::<
                    ImageArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <ImageArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::Buffer(ref val) => fidl::encoding::encode_in_envelope::<
                    BufferArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <BufferArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::View(ref mut val) => fidl::encoding::encode_in_envelope::<
                    ViewArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <ViewArgs as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::ViewHolder(ref mut val) => fidl::encoding::encode_in_envelope::<
                    ViewHolderArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <ViewHolderArgs as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::Rectangle(ref val) => fidl::encoding::encode_in_envelope::<
                    RectangleArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <RectangleArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::RoundedRectangle(ref val) => fidl::encoding::encode_in_envelope::<
                    RoundedRectangleArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <RoundedRectangleArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::Circle(ref val) => fidl::encoding::encode_in_envelope::<
                    CircleArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <CircleArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::Mesh(ref val) => fidl::encoding::encode_in_envelope::<
                    MeshArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <MeshArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::ShapeNode(ref val) => fidl::encoding::encode_in_envelope::<
                    ShapeNodeArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <ShapeNodeArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::ClipNode(ref val) => fidl::encoding::encode_in_envelope::<
                    ClipNodeArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <ClipNodeArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::EntityNode(ref val) => fidl::encoding::encode_in_envelope::<
                    EntityNodeArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <EntityNodeArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::OpacityNode(ref val) => fidl::encoding::encode_in_envelope::<
                    OpacityNodeArgsHack,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <OpacityNodeArgsHack as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::Material(ref val) => fidl::encoding::encode_in_envelope::<
                    MaterialArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <MaterialArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::Compositor(ref val) => fidl::encoding::encode_in_envelope::<
                    CompositorArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <CompositorArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::DisplayCompositor(ref val) => fidl::encoding::encode_in_envelope::<
                    DisplayCompositorArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <DisplayCompositorArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::LayerStack(ref val) => fidl::encoding::encode_in_envelope::<
                    LayerStackArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <LayerStackArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::Layer(ref val) => fidl::encoding::encode_in_envelope::<
                    LayerArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <LayerArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::Scene(ref val) => fidl::encoding::encode_in_envelope::<
                    SceneArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <SceneArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::Camera(ref val) => fidl::encoding::encode_in_envelope::<
                    CameraArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <CameraArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::StereoCamera(ref val) => fidl::encoding::encode_in_envelope::<
                    StereoCameraArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <StereoCameraArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::Renderer(ref val) => fidl::encoding::encode_in_envelope::<
                    RendererArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <RendererArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::AmbientLight(ref val) => fidl::encoding::encode_in_envelope::<
                    AmbientLightArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <AmbientLightArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::DirectionalLight(ref val) => fidl::encoding::encode_in_envelope::<
                    DirectionalLightArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <DirectionalLightArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::Variable(ref val) => fidl::encoding::encode_in_envelope::<
                    VariableArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <VariableArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::PointLight(ref val) => fidl::encoding::encode_in_envelope::<
                    PointLightArgs,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <PointLightArgs as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::View3(ref mut val) => fidl::encoding::encode_in_envelope::<
                    ViewArgs3,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <ViewArgs3 as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::ImagePipe2(ref mut val) => fidl::encoding::encode_in_envelope::<
                    ImagePipe2Args,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <ImagePipe2Args as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::Image2(ref val) => fidl::encoding::encode_in_envelope::<
                    ImageArgs2,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <ImageArgs2 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                ResourceArgs::Image3(ref mut val) => fidl::encoding::encode_in_envelope::<
                    ImageArgs3,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <ImageArgs3 as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
            }
        }
    }

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

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

            let member_inline_size = match ordinal {
                1 => <MemoryArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <ImageArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                4 => <BufferArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                5 => <ViewArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                6 => <ViewHolderArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                7 => <RectangleArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                8 => <RoundedRectangleArgs as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                9 => <CircleArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                10 => <MeshArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                11 => <ShapeNodeArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                12 => <ClipNodeArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                13 => <EntityNodeArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                14 => <OpacityNodeArgsHack as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                15 => <MaterialArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                16 => <CompositorArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                17 => <DisplayCompositorArgs as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                19 => <LayerStackArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                20 => <LayerArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                21 => <SceneArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                22 => <CameraArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                23 => {
                    <StereoCameraArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context)
                }
                24 => <RendererArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                25 => {
                    <AmbientLightArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context)
                }
                26 => <DirectionalLightArgs as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                27 => <VariableArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                28 => <PointLightArgs as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                31 => <ViewArgs3 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                32 => <ImagePipe2Args as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                33 => <ImageArgs2 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                34 => <ImageArgs3 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                _ => return Err(fidl::Error::UnknownUnionTag),
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Memory(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::Memory(fidl::new_empty!(
                            MemoryArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Memory(ref mut val) = self {
                        fidl::decode!(
                            MemoryArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Image(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::Image(fidl::new_empty!(
                            ImageArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Image(ref mut val) = self {
                        fidl::decode!(
                            ImageArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                4 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Buffer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::Buffer(fidl::new_empty!(
                            BufferArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Buffer(ref mut val) = self {
                        fidl::decode!(
                            BufferArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                5 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::View(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::View(fidl::new_empty!(
                            ViewArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::View(ref mut val) = self {
                        fidl::decode!(
                            ViewArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                6 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::ViewHolder(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::ViewHolder(fidl::new_empty!(
                            ViewHolderArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::ViewHolder(ref mut val) = self {
                        fidl::decode!(
                            ViewHolderArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                7 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Rectangle(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::Rectangle(fidl::new_empty!(
                            RectangleArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Rectangle(ref mut val) = self {
                        fidl::decode!(
                            RectangleArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                8 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::RoundedRectangle(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::RoundedRectangle(fidl::new_empty!(
                            RoundedRectangleArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::RoundedRectangle(ref mut val) = self {
                        fidl::decode!(
                            RoundedRectangleArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                9 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Circle(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::Circle(fidl::new_empty!(
                            CircleArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Circle(ref mut val) = self {
                        fidl::decode!(
                            CircleArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                10 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Mesh(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::Mesh(fidl::new_empty!(
                            MeshArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Mesh(ref mut val) = self {
                        fidl::decode!(
                            MeshArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                11 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::ShapeNode(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::ShapeNode(fidl::new_empty!(
                            ShapeNodeArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::ShapeNode(ref mut val) = self {
                        fidl::decode!(
                            ShapeNodeArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                12 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::ClipNode(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::ClipNode(fidl::new_empty!(
                            ClipNodeArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::ClipNode(ref mut val) = self {
                        fidl::decode!(
                            ClipNodeArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                13 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::EntityNode(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::EntityNode(fidl::new_empty!(
                            EntityNodeArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::EntityNode(ref mut val) = self {
                        fidl::decode!(
                            EntityNodeArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                14 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::OpacityNode(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::OpacityNode(fidl::new_empty!(
                            OpacityNodeArgsHack,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::OpacityNode(ref mut val) = self {
                        fidl::decode!(
                            OpacityNodeArgsHack,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                15 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Material(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::Material(fidl::new_empty!(
                            MaterialArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Material(ref mut val) = self {
                        fidl::decode!(
                            MaterialArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                16 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Compositor(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::Compositor(fidl::new_empty!(
                            CompositorArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Compositor(ref mut val) = self {
                        fidl::decode!(
                            CompositorArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                17 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::DisplayCompositor(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::DisplayCompositor(fidl::new_empty!(
                            DisplayCompositorArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::DisplayCompositor(ref mut val) = self {
                        fidl::decode!(
                            DisplayCompositorArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                19 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::LayerStack(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::LayerStack(fidl::new_empty!(
                            LayerStackArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::LayerStack(ref mut val) = self {
                        fidl::decode!(
                            LayerStackArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                20 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Layer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::Layer(fidl::new_empty!(
                            LayerArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Layer(ref mut val) = self {
                        fidl::decode!(
                            LayerArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                21 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Scene(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::Scene(fidl::new_empty!(
                            SceneArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Scene(ref mut val) = self {
                        fidl::decode!(
                            SceneArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                22 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Camera(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::Camera(fidl::new_empty!(
                            CameraArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Camera(ref mut val) = self {
                        fidl::decode!(
                            CameraArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                23 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::StereoCamera(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::StereoCamera(fidl::new_empty!(
                            StereoCameraArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::StereoCamera(ref mut val) = self {
                        fidl::decode!(
                            StereoCameraArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                24 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Renderer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::Renderer(fidl::new_empty!(
                            RendererArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Renderer(ref mut val) = self {
                        fidl::decode!(
                            RendererArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                25 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::AmbientLight(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::AmbientLight(fidl::new_empty!(
                            AmbientLightArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::AmbientLight(ref mut val) = self {
                        fidl::decode!(
                            AmbientLightArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                26 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::DirectionalLight(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::DirectionalLight(fidl::new_empty!(
                            DirectionalLightArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::DirectionalLight(ref mut val) = self {
                        fidl::decode!(
                            DirectionalLightArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                27 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Variable(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::Variable(fidl::new_empty!(
                            VariableArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Variable(ref mut val) = self {
                        fidl::decode!(
                            VariableArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                28 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::PointLight(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::PointLight(fidl::new_empty!(
                            PointLightArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::PointLight(ref mut val) = self {
                        fidl::decode!(
                            PointLightArgs,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                31 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::View3(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::View3(fidl::new_empty!(
                            ViewArgs3,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::View3(ref mut val) = self {
                        fidl::decode!(
                            ViewArgs3,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                32 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::ImagePipe2(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::ImagePipe2(fidl::new_empty!(
                            ImagePipe2Args,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::ImagePipe2(ref mut val) = self {
                        fidl::decode!(
                            ImagePipe2Args,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                33 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Image2(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::Image2(fidl::new_empty!(
                            ImageArgs2,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Image2(ref mut val) = self {
                        fidl::decode!(
                            ImageArgs2,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                34 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Image3(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ResourceArgs::Image3(fidl::new_empty!(
                            ImageArgs3,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ResourceArgs::Image3(ref mut val) = self {
                        fidl::decode!(
                            ImageArgs3,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }
}