fidl_fuchsia_hardware_display_common/

fidl_fuchsia_hardware_display_common.rs

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

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

use bitflags::bitflags;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

/// Type of the internal value in [`fuchsia.hardware.display/BufferCollectionId`].
pub type BufferCollectionIdValue = u64;

/// See [`fuchsia.hardware.display.types/ConfigStamp`].
pub type ConfigStampValue = u64;

/// Type of the internal value in [`fuchsia.hardware.display/EventId`].
pub type EventIdValue = u64;

/// Type of the internal value in [`ImageId`].
pub type ImageIdValue = u64;

/// Type of the internal value in [`LayerId`].
pub type LayerIdValue = u64;

/// Type of the internal value in [`VsyncAckCookie`].
pub type VsyncAckCookieValue = u64;

pub const IDENTIFIER_MAX_LEN: u32 = 128;

pub const INVALID_CONFIG_STAMP_VALUE: u64 = 0;

/// Constrains the use of `Coordinator.SetLayerImage2`; see documentation there.
pub const MAX_WAITING_IMAGES_PER_LAYER: u32 = 10;

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u8)]
pub enum VirtconMode {
    /// The Virtcon client owns the displays when there is no Primary client.
    Fallback = 0,
    /// The Virtcon client owns the displays even when a Primary client is
    /// connected.
    Forced = 1,
}

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

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

/// Identifies a sysmem BufferCollection owned by a Display Coordinator client.
///
/// Values are managed by [`fuchsia.hardware.display/Coordinator`] clients, to
/// facilitate feed-forward dataflow.
///
/// Each value uniquely identifies a [`fuchsia.sysmem/BufferCollection`] (as
/// well as its token [`fuchsia.sysmem/BufferCollectionToken`]) imported to the
/// Display Coordinator device within a Coordinator connection. The identifier
/// of a BufferCollection destroyed via
/// [`fuchsia.hardware.display/Coordinator.ReleaseBufferCollection`] can be
/// reused in a subsequent
/// [`fuchsia.hardware.display/Coordinator.ImportBufferCollection`] call.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct BufferCollectionId {
    pub value: u64,
}

impl fidl::Persistable for BufferCollectionId {}

/// Identifies a single buffer within a sysmem BufferCollection owned by a
/// Display Coordinator client.
///
/// A [`fuchsia.sysmem/BufferCollection`] may allocate multiple buffers at a
/// time. This identifies the specific buffer at `buffer_index` within the
/// shared BufferCollection identified by `buffer_collection_id`.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct BufferId {
    pub buffer_collection_id: BufferCollectionId,
    pub buffer_index: u32,
}

impl fidl::Persistable for BufferId {}

#[derive(Clone, Debug, PartialEq)]
pub struct ClientCompositionOp {
    /// display_id and layer_id uniquely identify the subject of the
    /// opcode.
    pub display_id: fidl_fuchsia_hardware_display_types::DisplayId,
    /// Invalid for issues that aren't scoped to a specific layer, such as
    /// unsupported color conversion tables.
    pub layer_id: LayerId,
    pub opcode: fidl_fuchsia_hardware_display_types::ClientCompositionOpcode,
}

impl fidl::Persistable for ClientCompositionOp {}

/// Identifies a display configuration submitted to the Coordinator.
///
/// This is a type-safe wrapper for a
/// [`fuchsia.hardware.display/ConfigStampValue`], which is a raw numeric value.
///
/// Values are unique within a Display Coordinator client connection.
///
/// Clients create new values when they call
/// [`fuchsia.hardware.display/Coordinator.ApplyConfig3`].  The values are used
/// by the Display Coordinator to identify configurations in
/// [`fuchsia.hardware.display/CoordinatorListener.OnVsync`] calls.
///
/// Clients must create strictly increasing (unique, strictly monotonic) values
/// within the lifetime of a [`fuchsia.display/Coordinator`] connection.
///
/// [`fuchsia.hardware.display/INVALID_CONFIG_STAMP_VALUE`] represents an
/// invalid value.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ConfigStamp {
    pub value: u64,
}

impl fidl::Persistable for ConfigStamp {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CoordinatorAcknowledgeVsyncRequest {
    /// The cookie received in the most recent `OnVsync` message.
    ///
    /// Must not be zero. Zero cookies do not require acknowledgement.
    ///
    /// Each cookie must be acknowledged exactly once. Cookies must
    /// be acknowledged in the order of their receipt.
    pub cookie: u64,
}

impl fidl::Persistable for CoordinatorAcknowledgeVsyncRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorCheckConfigRequest {
    /// If is true, the draft changes will be discarded after validation.
    ///
    /// TODO(https://fxbug.dev/395488933): Deprecated; always set this to
    /// false. Call [`Coordinator.DiscardConfig`] instead.
    pub discard: bool,
}

impl fidl::Persistable for CoordinatorCheckConfigRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct CoordinatorCheckConfigResponse {
    pub res: fidl_fuchsia_hardware_display_types::ConfigResult,
    /// Non-empty iff `res` is UNSUPPORTED_CONFIG.
    pub ops: Vec<ClientCompositionOp>,
}

impl fidl::Persistable for CoordinatorCheckConfigResponse {}

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

impl fidl::Persistable for CoordinatorDestroyLayerRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CoordinatorGetLatestAppliedConfigStampResponse {
    pub stamp: ConfigStamp,
}

impl fidl::Persistable for CoordinatorGetLatestAppliedConfigStampResponse {}

#[derive(Clone, Debug, PartialEq)]
pub struct CoordinatorImportImageRequest {
    pub image_metadata: fidl_fuchsia_hardware_display_types::ImageMetadata,
    pub buffer_id: BufferId,
    pub image_id: ImageId,
}

impl fidl::Persistable for CoordinatorImportImageRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorListenerOnClientOwnershipChangeRequest {
    pub has_ownership: bool,
}

impl fidl::Persistable for CoordinatorListenerOnClientOwnershipChangeRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct CoordinatorListenerOnDisplaysChangedRequest {
    pub added: Vec<Info>,
    pub removed: Vec<fidl_fuchsia_hardware_display_types::DisplayId>,
}

impl fidl::Persistable for CoordinatorListenerOnDisplaysChangedRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct CoordinatorListenerOnVsyncRequest {
    /// The display associated with the VSync event.
    pub display_id: fidl_fuchsia_hardware_display_types::DisplayId,
    /// The time when the VSync occurred.
    ///
    /// The accurrancy of this timestamp depends on the display hardware.
    pub timestamp: i64,
    /// Identifies the lastest configuration fully applied to the display.
    ///
    /// Guaranteed to be a valid value.
    ///
    /// If a configuration contains images that are still waiting to be
    /// ready, that configuration will be only partially applied (without
    /// the waiting image). That configuration's stamp will not be reported
    /// here.
    pub applied_config_stamp: ConfigStamp,
    /// Used to acknowledge the receipt of VSync events.
    ///
    /// A value of zero means no acknowledgement is required by the
    /// client.
    ///
    /// Each non-zero cookie must be acknowledged immediately, via a call to
    /// [`Coordinator.AcknowledgeVsync`]. Cookies must be acknowledged even
    /// if the client does not change the display's configuration.
    pub cookie: VsyncAckCookie,
}

impl fidl::Persistable for CoordinatorListenerOnVsyncRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CoordinatorReleaseBufferCollectionRequest {
    pub buffer_collection_id: BufferCollectionId,
}

impl fidl::Persistable for CoordinatorReleaseBufferCollectionRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CoordinatorReleaseEventRequest {
    pub id: EventId,
}

impl fidl::Persistable for CoordinatorReleaseEventRequest {}

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

impl fidl::Persistable for CoordinatorReleaseImageRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct CoordinatorSetBufferCollectionConstraintsRequest {
    pub buffer_collection_id: BufferCollectionId,
    pub buffer_usage: fidl_fuchsia_hardware_display_types::ImageBufferUsage,
}

impl fidl::Persistable for CoordinatorSetBufferCollectionConstraintsRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct CoordinatorSetDisplayColorConversionRequest {
    /// The display whose color coefficients are set.
    ///
    /// The call is ignored if the display ID does not belong to a display
    /// known by the Coordinator. This can happen if a client issues a call
    /// to [`Coordinator.SetDisplayColorConversion`] before it receives a
    /// notification that the display was removed.
    pub display_id: fidl_fuchsia_hardware_display_types::DisplayId,
    pub preoffsets: [f32; 3],
    pub coefficients: [f32; 9],
    pub postoffsets: [f32; 3],
}

impl fidl::Persistable for CoordinatorSetDisplayColorConversionRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct CoordinatorSetDisplayLayersRequest {
    /// The display that will show the result of compositing the layers.
    ///
    /// The call is ignored if the display ID does not belong to a display
    /// known by the Coordinator. This can happen if a client issues a call
    /// to [`Coordinator.SetDisplayLayers`] before it receives a
    /// notification that the display was removed.
    pub display_id: fidl_fuchsia_hardware_display_types::DisplayId,
    pub layer_ids: Vec<LayerId>,
}

impl fidl::Persistable for CoordinatorSetDisplayLayersRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct CoordinatorSetDisplayModeRequest {
    /// The display whose mode is changed.
    ///
    /// The call is ignored if the display ID does not belong to a display
    /// known by the Coordinator. This can happen if a client issues a call
    /// to [`Coordinator.SetDisplayMode`] before it receives a notification
    /// that the display was removed.
    pub display_id: fidl_fuchsia_hardware_display_types::DisplayId,
    /// The new mode for the display.
    ///
    /// Must be one of the [`Info.modes`] entries for the display.
    pub mode: fidl_fuchsia_hardware_display_types::Mode,
}

impl fidl::Persistable for CoordinatorSetDisplayModeRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct CoordinatorSetDisplayPowerRequest {
    pub display_id: fidl_fuchsia_hardware_display_types::DisplayId,
    /// True powers on the display, false powers it off.
    ///
    /// Once a display is turned off, the hardware will not generate new
    /// VSync events. However, the client should be prepared to handle VSync
    /// events generated before the [`Coordinator.SetDisplayPower`] call
    /// reaches the hardware.
    ///
    /// Calls that impact draft configurations, such as
    /// [`Coordinator.SetDisplayLayers`], still work while the display is
    /// powered off.
    ///
    /// [`Coordinator.ApplyConfig`] also works while the display is powered
    /// off.  When the display is powered back on on, it will show the
    /// latest applied configuration.
    ///
    /// Newly added displays are powered on.
    pub power_on: bool,
}

impl fidl::Persistable for CoordinatorSetDisplayPowerRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct CoordinatorSetLayerColorConfigRequest {
    pub layer_id: LayerId,
    pub color: fidl_fuchsia_hardware_display_types::Color,
}

impl fidl::Persistable for CoordinatorSetLayerColorConfigRequest {}

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

impl fidl::Persistable for CoordinatorSetLayerImage2Request {}

#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
pub struct CoordinatorSetLayerPrimaryAlphaRequest {
    pub layer_id: LayerId,
    pub mode: fidl_fuchsia_hardware_display_types::AlphaMode,
    pub val: f32,
}

impl fidl::Persistable for CoordinatorSetLayerPrimaryAlphaRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct CoordinatorSetLayerPrimaryConfigRequest {
    pub layer_id: LayerId,
    pub image_metadata: fidl_fuchsia_hardware_display_types::ImageMetadata,
}

impl fidl::Persistable for CoordinatorSetLayerPrimaryConfigRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct CoordinatorSetLayerPrimaryPositionRequest {
    pub layer_id: LayerId,
    /// Applied to the input image pixels specified by `image_source`.
    ///
    /// `display_destination` must account for image dimensions changes
    /// caused by rotations. For example, rotating a 600x300 pixel image by
    /// 90 degrees would specify 300x600 pixel dimensions in
    /// `display_destination`.
    pub image_source_transformation: fidl_fuchsia_hardware_display_types::CoordinateTransformation,
    /// The associated image region whose pixels are drawn by the layer.
    ///
    /// The rectangle uses the Vulkan coordinate space. The origin is at the
    /// image's top-left corner. The X axis points to the right, and the Y
    /// axis points downwards.
    ///
    /// A valid layer definition requires a valid non-empty image source
    /// rectangle that is entirely contained within the image.
    ///
    /// Hardware image cropping is requested implicitly, when the source
    /// region's dimensions differ from the image's dimensions. Some display
    /// hardware may not support cropping.
    pub image_source: fidl_fuchsia_math::RectU,
    /// The display image (composited output) region occupied by the layer.
    ///
    /// The rectangle uses the Vulkan coordinate space. The origin is at the
    /// display's top-left corner. The X axis points to the right, and the Y
    /// axis points downwards.
    ///
    /// A valid layer definition requires a valid non-empty display
    /// destination rectangle that is entirely contained within the display.
    ///
    /// Hardware image scaling is requested implicitly, when the output
    /// region's dimensions differ from the dimensions of `image_source`.
    /// Some display hardware may not support scaling. All display hardware
    /// has limitations in scaling support.
    pub display_destination: fidl_fuchsia_math::RectU,
}

impl fidl::Persistable for CoordinatorSetLayerPrimaryPositionRequest {}

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

impl fidl::Persistable for CoordinatorSetMinimumRgbRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorSetVirtconModeRequest {
    pub mode: VirtconMode,
}

impl fidl::Persistable for CoordinatorSetVirtconModeRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorSetVsyncEventDeliveryRequest {
    /// If false, the client will not receive `OnVsync` messages.
    pub vsync_delivery_enabled: bool,
}

impl fidl::Persistable for CoordinatorSetVsyncEventDeliveryRequest {}

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

impl fidl::Persistable for CoordinatorStartCaptureRequest {}

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

impl fidl::Persistable for CoordinatorCreateLayerResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorIsCaptureSupportedResponse {
    pub supported: bool,
}

impl fidl::Persistable for CoordinatorIsCaptureSupportedResponse {}

/// Identifies a Zircon event shared between the Display Coordinator and a
/// client.
///
/// [`fuchsia.hardware.display.types/INVALID_DISP_ID`] represents an invalid
/// value.
///
/// Values are managed by [`fuchsia.hardware.display/Coordinator`] clients, to
/// facilitate feed-forward dataflow.
///
/// Valid values uniquely identify Zircon events imported to the Coordinator
/// within a display Coordinator connection.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct EventId {
    pub value: u64,
}

impl fidl::Persistable for EventId {}

/// Unique identifier for an image registered with the display coordinator.
///
/// [`fuchsia.hardware.display.types/INVALID_DISP_ID`] represents an invalid
/// value.
///
/// Values are managed by [`fuchsia.hardware.display/Coordinator`] clients, to
/// facilitate feed-forward dataflow.
///
/// Valid values uniquely identify "live" images within a Display Coordinator
/// connection. The identifier of an image destroyed via
/// [`fuchsia.hardware.display/Coordinator.ReleaseImage`] can be reused in a
/// subsequent [`fuchsia.hardware.display/Coordinator.ImportImage`] call.
///
/// An image is a memory buffer whose bytes have a fixed interpretation as an
/// array of pixels. Memory buffers are managed by sysmem, and are accessed by
/// the display stack using a [`fuchsia.sysmem/BufferCollection`]. The buffer's
/// interpretation is described by an
/// [`fuchsia.hardware.display.types/ImageConfig`].
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ImageId {
    pub value: u64,
}

impl fidl::Persistable for ImageId {}

/// Description for a display device attached to the system.
///
/// Display devices include external monitors and internal panels.
#[derive(Clone, Debug, PartialEq)]
pub struct Info {
    /// Uniquely identifies the display in a Controller connection.
    ///
    /// See [`fuchsia.hardware.display.types/DisplayId`].
    pub id: fidl_fuchsia_hardware_display_types::DisplayId,
    /// Operational modes supported by the described display device.
    ///
    /// The first entry is the device's preferred mode.
    pub modes: Vec<fidl_fuchsia_hardware_display_types::Mode>,
    /// Pixel formats that can be directly displayed on the attached display.
    ///
    /// This field will be revised to better reflect the subtleties around
    /// modern display hardware, such as multiple layer types, and around
    /// pixel format modifiers, such as tiling and framebuffer compression
    /// formats. See https://fxbug.dev/42072347 and https://fxbug.dev/42076907.
    ///
    /// The formats listed here reflect support from both the display engine
    /// hardware and the display device. This means some of the formats may be
    /// subject to conversion inside the display engine hardware.
    ///
    /// The first entry in the list is the display's preferred format. This
    /// format is likely to be supported for transferring data between the
    /// display engine and the display hardware, and not require any conversion
    /// inside the display engine.
    ///
    /// Format conversion inside the display engine is likely to be
    /// significantly more power-efficient than a GPU render stage or software
    /// conversion. So, using any format in this list is better than using the
    /// GPU to convert to the preferred format.
    pub pixel_format: Vec<fidl_fuchsia_images2::PixelFormat>,
    /// Part of a display device identifier that persists across boot cycles.
    ///
    /// If the `manufacturer_name`, `monitor_name` and `monitor_serial` fields
    /// are all non-empty, they  make up an identifier that is likely to be
    /// unique to the attached device, and is highly unlikely to change across
    /// boot cycles. Software that needs to identify displays (for example, to
    /// honor display-specific preferences) should use this triplet.
    pub manufacturer_name: String,
    /// Part of a display device identifier that persists across boot cycles.
    ///
    /// See `manufacturer_name` for details.
    pub monitor_name: String,
    /// Part of a display device identifier that persists across boot cycles.
    ///
    /// See `manufacturer_name` for details.
    pub monitor_serial: String,
    /// Physical horizontal size of the displayed image area, in millimeters.
    ///
    /// If `using_fallback_size` is true, the value is a best guess from the
    /// driver. Otherwise, the value here is reported by the display device.
    pub horizontal_size_mm: u32,
    /// Physical vertical size of the displayed image area, in millimeters.
    ///
    /// See `horizontal_size_mm` for more details.
    pub vertical_size_mm: u32,
    /// True if the driver does not have the display's physical sizing info.
    pub using_fallback_size: bool,
}

impl fidl::Persistable for Info {}

/// Identifies a layer resource owned by a Display Coordinator client.
///
/// [`fuchsia.hardware.display.types/INVALID_DISP_ID`] represents an invalid
/// value.
///
/// Values are managed by [`fuchsia.hardware.display/Coordinator`] clients, to
/// facilitate feed-forward dataflow.
///
/// Valid values uniquely identify "live" layers within a Display Coordinator
/// connection. The identifier of a layer destroyed via
/// [`fuchsia.hardware.display/Coordinator.DestroyLayer`] can be reused in a
/// subsequent [`fuchsia.hardware.display/Coordinator.CreateLayer`] call.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct LayerId {
    pub value: u64,
}

impl fidl::Persistable for LayerId {}

/// Identifies a unique identifier ("cookie") of a Vertical Synchronization
/// (Vsync) signal.
///
/// [`fuchsia.hardware.display.types/INVALID_DISP_ID`] represents an invalid
/// value.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct VsyncAckCookie {
    pub value: u64,
}

impl fidl::Persistable for VsyncAckCookie {}

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

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

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

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

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

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

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

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

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

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BufferId {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                buffer_collection_id: fidl::new_empty!(BufferCollectionId, D),
                buffer_index: fidl::new_empty!(u32, D),
            }
        }

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

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ClientCompositionOp, D>
        for &ClientCompositionOp
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ClientCompositionOp>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ClientCompositionOp, D>::encode(
                (
                    <fidl_fuchsia_hardware_display_types::DisplayId as fidl::encoding::ValueTypeMarker>::borrow(&self.display_id),
                    <LayerId as fidl::encoding::ValueTypeMarker>::borrow(&self.layer_id),
                    <fidl_fuchsia_hardware_display_types::ClientCompositionOpcode as fidl::encoding::ValueTypeMarker>::borrow(&self.opcode),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl_fuchsia_hardware_display_types::DisplayId, D>,
            T1: fidl::encoding::Encode<LayerId, D>,
            T2: fidl::encoding::Encode<fidl_fuchsia_hardware_display_types::ClientCompositionOpcode, D>,
        > fidl::encoding::Encode<ClientCompositionOp, D> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ClientCompositionOp>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut 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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ClientCompositionOp {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                display_id: fidl::new_empty!(fidl_fuchsia_hardware_display_types::DisplayId, D),
                layer_id: fidl::new_empty!(LayerId, D),
                opcode: fidl::new_empty!(
                    fidl_fuchsia_hardware_display_types::ClientCompositionOpcode,
                    D
                ),
            }
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(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_hardware_display_types::ConfigResult,
                D,
                &mut self.res,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<ClientCompositionOp>,
                D,
                &mut self.ops,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<CoordinatorImportImageRequest, D>
        for &CoordinatorImportImageRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorImportImageRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CoordinatorImportImageRequest, D>::encode(
                (
                    <fidl_fuchsia_hardware_display_types::ImageMetadata as fidl::encoding::ValueTypeMarker>::borrow(&self.image_metadata),
                    <BufferId as fidl::encoding::ValueTypeMarker>::borrow(&self.buffer_id),
                    <ImageId as fidl::encoding::ValueTypeMarker>::borrow(&self.image_id),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl_fuchsia_hardware_display_types::ImageMetadata, D>,
            T1: fidl::encoding::Encode<BufferId, D>,
            T2: fidl::encoding::Encode<ImageId, D>,
        > fidl::encoding::Encode<CoordinatorImportImageRequest, D> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorImportImageRequest>(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 + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoordinatorImportImageRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                image_metadata: fidl::new_empty!(
                    fidl_fuchsia_hardware_display_types::ImageMetadata,
                    D
                ),
                buffer_id: fidl::new_empty!(BufferId, D),
                image_id: fidl::new_empty!(ImageId, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // 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_hardware_display_types::ImageMetadata,
                D,
                &mut self.image_metadata,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(BufferId, D, &mut self.buffer_id, decoder, offset + 16, _depth)?;
            fidl::decode!(ImageId, D, &mut self.image_id, decoder, offset + 32, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<CoordinatorListenerOnDisplaysChangedRequest, D>
        for &CoordinatorListenerOnDisplaysChangedRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorListenerOnDisplaysChangedRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CoordinatorListenerOnDisplaysChangedRequest, D>::encode(
                (
                    <fidl::encoding::UnboundedVector<Info> as fidl::encoding::ValueTypeMarker>::borrow(&self.added),
                    <fidl::encoding::UnboundedVector<fidl_fuchsia_hardware_display_types::DisplayId> as fidl::encoding::ValueTypeMarker>::borrow(&self.removed),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Info>, D>,
            T1: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<fidl_fuchsia_hardware_display_types::DisplayId>,
                D,
            >,
        > fidl::encoding::Encode<CoordinatorListenerOnDisplaysChangedRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorListenerOnDisplaysChangedRequest>(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 + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoordinatorListenerOnDisplaysChangedRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                added: fidl::new_empty!(fidl::encoding::UnboundedVector<Info>, D),
                removed: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<fidl_fuchsia_hardware_display_types::DisplayId>,
                    D
                ),
            }
        }

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

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<CoordinatorListenerOnVsyncRequest, D>
        for &CoordinatorListenerOnVsyncRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorListenerOnVsyncRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CoordinatorListenerOnVsyncRequest, D>::encode(
                (
                    <fidl_fuchsia_hardware_display_types::DisplayId as fidl::encoding::ValueTypeMarker>::borrow(&self.display_id),
                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timestamp),
                    <ConfigStamp as fidl::encoding::ValueTypeMarker>::borrow(&self.applied_config_stamp),
                    <VsyncAckCookie as fidl::encoding::ValueTypeMarker>::borrow(&self.cookie),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl_fuchsia_hardware_display_types::DisplayId, D>,
            T1: fidl::encoding::Encode<i64, D>,
            T2: fidl::encoding::Encode<ConfigStamp, D>,
            T3: fidl::encoding::Encode<VsyncAckCookie, D>,
        > fidl::encoding::Encode<CoordinatorListenerOnVsyncRequest, D> for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorListenerOnVsyncRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 16, depth)?;
            self.3.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoordinatorListenerOnVsyncRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                display_id: fidl::new_empty!(fidl_fuchsia_hardware_display_types::DisplayId, D),
                timestamp: fidl::new_empty!(i64, D),
                applied_config_stamp: fidl::new_empty!(ConfigStamp, D),
                cookie: fidl::new_empty!(VsyncAckCookie, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl_fuchsia_hardware_display_types::DisplayId,
                D,
                &mut self.display_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(i64, D, &mut self.timestamp, decoder, offset + 8, _depth)?;
            fidl::decode!(
                ConfigStamp,
                D,
                &mut self.applied_config_stamp,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(VsyncAckCookie, D, &mut self.cookie, decoder, offset + 24, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoordinatorSetBufferCollectionConstraintsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                buffer_collection_id: fidl::new_empty!(BufferCollectionId, D),
                buffer_usage: fidl::new_empty!(
                    fidl_fuchsia_hardware_display_types::ImageBufferUsage,
                    D
                ),
            }
        }

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

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<CoordinatorSetDisplayColorConversionRequest, D>
        for &CoordinatorSetDisplayColorConversionRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorSetDisplayColorConversionRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CoordinatorSetDisplayColorConversionRequest, D>::encode(
                (
                    <fidl_fuchsia_hardware_display_types::DisplayId as fidl::encoding::ValueTypeMarker>::borrow(&self.display_id),
                    <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.preoffsets),
                    <fidl::encoding::Array<f32, 9> as fidl::encoding::ValueTypeMarker>::borrow(&self.coefficients),
                    <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.postoffsets),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl_fuchsia_hardware_display_types::DisplayId, D>,
            T1: fidl::encoding::Encode<fidl::encoding::Array<f32, 3>, D>,
            T2: fidl::encoding::Encode<fidl::encoding::Array<f32, 9>, D>,
            T3: fidl::encoding::Encode<fidl::encoding::Array<f32, 3>, D>,
        > fidl::encoding::Encode<CoordinatorSetDisplayColorConversionRequest, D>
        for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorSetDisplayColorConversionRequest>(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(64);
                (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 + 20, depth)?;
            self.3.encode(encoder, offset + 56, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoordinatorSetDisplayColorConversionRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                display_id: fidl::new_empty!(fidl_fuchsia_hardware_display_types::DisplayId, D),
                preoffsets: fidl::new_empty!(fidl::encoding::Array<f32, 3>, D),
                coefficients: fidl::new_empty!(fidl::encoding::Array<f32, 9>, D),
                postoffsets: fidl::new_empty!(fidl::encoding::Array<f32, 3>, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(64) };
            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 + 64 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl_fuchsia_hardware_display_types::DisplayId,
                D,
                &mut self.display_id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::Array<f32, 3>, D, &mut self.preoffsets, decoder, offset + 8, _depth)?;
            fidl::decode!(fidl::encoding::Array<f32, 9>, D, &mut self.coefficients, decoder, offset + 20, _depth)?;
            fidl::decode!(fidl::encoding::Array<f32, 3>, D, &mut self.postoffsets, decoder, offset + 56, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoordinatorSetDisplayLayersRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                display_id: fidl::new_empty!(fidl_fuchsia_hardware_display_types::DisplayId, D),
                layer_ids: fidl::new_empty!(fidl::encoding::UnboundedVector<LayerId>, D),
            }
        }

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

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

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

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

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

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

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoordinatorSetDisplayModeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                display_id: fidl::new_empty!(fidl_fuchsia_hardware_display_types::DisplayId, D),
                mode: fidl::new_empty!(fidl_fuchsia_hardware_display_types::Mode, D),
            }
        }

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

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

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

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

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

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

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoordinatorSetDisplayPowerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                display_id: fidl::new_empty!(fidl_fuchsia_hardware_display_types::DisplayId, D),
                power_on: fidl::new_empty!(bool, D),
            }
        }

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

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

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

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

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

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

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoordinatorSetLayerColorConfigRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                layer_id: fidl::new_empty!(LayerId, D),
                color: fidl::new_empty!(fidl_fuchsia_hardware_display_types::Color, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const 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!(LayerId, D, &mut self.layer_id, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_hardware_display_types::Color,
                D,
                &mut self.color,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoordinatorSetLayerImage2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                layer_id: fidl::new_empty!(LayerId, D),
                image_id: fidl::new_empty!(ImageId, D),
                wait_event_id: fidl::new_empty!(EventId, D),
            }
        }

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

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

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

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

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

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

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoordinatorSetLayerPrimaryAlphaRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                layer_id: fidl::new_empty!(LayerId, D),
                mode: fidl::new_empty!(fidl_fuchsia_hardware_display_types::AlphaMode, D),
                val: fidl::new_empty!(f32, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffff00u64;
            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!(LayerId, D, &mut self.layer_id, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_hardware_display_types::AlphaMode,
                D,
                &mut self.mode,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(f32, D, &mut self.val, decoder, offset + 12, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoordinatorSetLayerPrimaryConfigRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                layer_id: fidl::new_empty!(LayerId, D),
                image_metadata: fidl::new_empty!(
                    fidl_fuchsia_hardware_display_types::ImageMetadata,
                    D
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const 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!(LayerId, D, &mut self.layer_id, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_hardware_display_types::ImageMetadata,
                D,
                &mut self.image_metadata,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<CoordinatorSetLayerPrimaryPositionRequest, D>
        for &CoordinatorSetLayerPrimaryPositionRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorSetLayerPrimaryPositionRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CoordinatorSetLayerPrimaryPositionRequest, D>::encode(
                (
                    <LayerId as fidl::encoding::ValueTypeMarker>::borrow(&self.layer_id),
                    <fidl_fuchsia_hardware_display_types::CoordinateTransformation as fidl::encoding::ValueTypeMarker>::borrow(&self.image_source_transformation),
                    <fidl_fuchsia_math::RectU as fidl::encoding::ValueTypeMarker>::borrow(&self.image_source),
                    <fidl_fuchsia_math::RectU as fidl::encoding::ValueTypeMarker>::borrow(&self.display_destination),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<LayerId, D>,
            T1: fidl::encoding::Encode<
                fidl_fuchsia_hardware_display_types::CoordinateTransformation,
                D,
            >,
            T2: fidl::encoding::Encode<fidl_fuchsia_math::RectU, D>,
            T3: fidl::encoding::Encode<fidl_fuchsia_math::RectU, D>,
        > fidl::encoding::Encode<CoordinatorSetLayerPrimaryPositionRequest, D>
        for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CoordinatorSetLayerPrimaryPositionRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 12, depth)?;
            self.3.encode(encoder, offset + 28, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoordinatorSetLayerPrimaryPositionRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                layer_id: fidl::new_empty!(LayerId, D),
                image_source_transformation: fidl::new_empty!(
                    fidl_fuchsia_hardware_display_types::CoordinateTransformation,
                    D
                ),
                image_source: fidl::new_empty!(fidl_fuchsia_math::RectU, D),
                display_destination: fidl::new_empty!(fidl_fuchsia_math::RectU, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffff00u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(LayerId, D, &mut self.layer_id, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl_fuchsia_hardware_display_types::CoordinateTransformation,
                D,
                &mut self.image_source_transformation,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_math::RectU,
                D,
                &mut self.image_source,
                decoder,
                offset + 12,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_math::RectU,
                D,
                &mut self.display_destination,
                decoder,
                offset + 28,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for CoordinatorStartCaptureRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                signal_event_id: fidl::new_empty!(EventId, D),
                image_id: fidl::new_empty!(ImageId, D),
            }
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Info, D> for &Info {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Info>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Info, D>::encode(
                (
                    <fidl_fuchsia_hardware_display_types::DisplayId as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
                    <fidl::encoding::UnboundedVector<fidl_fuchsia_hardware_display_types::Mode> as fidl::encoding::ValueTypeMarker>::borrow(&self.modes),
                    <fidl::encoding::UnboundedVector<fidl_fuchsia_images2::PixelFormat> as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_format),
                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow(&self.manufacturer_name),
                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow(&self.monitor_name),
                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow(&self.monitor_serial),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.horizontal_size_mm),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.vertical_size_mm),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.using_fallback_size),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl_fuchsia_hardware_display_types::DisplayId, D>,
            T1: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<fidl_fuchsia_hardware_display_types::Mode>,
                D,
            >,
            T2: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<fidl_fuchsia_images2::PixelFormat>,
                D,
            >,
            T3: fidl::encoding::Encode<fidl::encoding::BoundedString<128>, D>,
            T4: fidl::encoding::Encode<fidl::encoding::BoundedString<128>, D>,
            T5: fidl::encoding::Encode<fidl::encoding::BoundedString<128>, D>,
            T6: fidl::encoding::Encode<u32, D>,
            T7: fidl::encoding::Encode<u32, D>,
            T8: fidl::encoding::Encode<bool, D>,
        > fidl::encoding::Encode<Info, D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Info>(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(96);
                (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 + 24, depth)?;
            self.3.encode(encoder, offset + 40, depth)?;
            self.4.encode(encoder, offset + 56, depth)?;
            self.5.encode(encoder, offset + 72, depth)?;
            self.6.encode(encoder, offset + 88, depth)?;
            self.7.encode(encoder, offset + 92, depth)?;
            self.8.encode(encoder, offset + 96, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Info {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(fidl_fuchsia_hardware_display_types::DisplayId, D),
                modes: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<fidl_fuchsia_hardware_display_types::Mode>,
                    D
                ),
                pixel_format: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<fidl_fuchsia_images2::PixelFormat>,
                    D
                ),
                manufacturer_name: fidl::new_empty!(fidl::encoding::BoundedString<128>, D),
                monitor_name: fidl::new_empty!(fidl::encoding::BoundedString<128>, D),
                monitor_serial: fidl::new_empty!(fidl::encoding::BoundedString<128>, D),
                horizontal_size_mm: fidl::new_empty!(u32, D),
                vertical_size_mm: fidl::new_empty!(u32, D),
                using_fallback_size: fidl::new_empty!(bool, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(96) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffffffffff00u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 96 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl_fuchsia_hardware_display_types::DisplayId,
                D,
                &mut self.id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<fidl_fuchsia_hardware_display_types::Mode>,
                D,
                &mut self.modes,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<fidl_fuchsia_images2::PixelFormat>,
                D,
                &mut self.pixel_format,
                decoder,
                offset + 24,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::BoundedString<128>,
                D,
                &mut self.manufacturer_name,
                decoder,
                offset + 40,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::BoundedString<128>,
                D,
                &mut self.monitor_name,
                decoder,
                offset + 56,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::BoundedString<128>,
                D,
                &mut self.monitor_serial,
                decoder,
                offset + 72,
                _depth
            )?;
            fidl::decode!(u32, D, &mut self.horizontal_size_mm, decoder, offset + 88, _depth)?;
            fidl::decode!(u32, D, &mut self.vertical_size_mm, decoder, offset + 92, _depth)?;
            fidl::decode!(bool, D, &mut self.using_fallback_size, decoder, offset + 96, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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