fidl_fuchsia_sysmem_common/

fidl_fuchsia_sysmem_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;

pub const FORMAT_MODIFIER_ARM_AFBC_16_X16: u64 = 576460752303423489;

pub const FORMAT_MODIFIER_ARM_AFBC_16_X16_SPLIT_BLOCK_SPARSE_YUV: u64 = 576460752303423601;

pub const FORMAT_MODIFIER_ARM_AFBC_16_X16_SPLIT_BLOCK_SPARSE_YUV_TE: u64 = 576460752303427697;

pub const FORMAT_MODIFIER_ARM_AFBC_16_X16_SPLIT_BLOCK_SPARSE_YUV_TE_TILED_HEADER: u64 =
    576460752303435889;

pub const FORMAT_MODIFIER_ARM_AFBC_16_X16_SPLIT_BLOCK_SPARSE_YUV_TILED_HEADER: u64 =
    576460752303431793;

pub const FORMAT_MODIFIER_ARM_AFBC_16_X16_TE: u64 = 576460752303427585;

pub const FORMAT_MODIFIER_ARM_AFBC_16_X16_YUV_TILED_HEADER: u64 = 576460752303431697;

pub const FORMAT_MODIFIER_ARM_AFBC_32_X8: u64 = 576460752303423490;

pub const FORMAT_MODIFIER_ARM_AFBC_32_X8_TE: u64 = 576460752303427586;

pub const FORMAT_MODIFIER_ARM_BCH_BIT: u64 = 2048;

pub const FORMAT_MODIFIER_ARM_LINEAR_TE: u64 = 576460752303427584;

pub const FORMAT_MODIFIER_ARM_SPARSE_BIT: u64 = 64;

pub const FORMAT_MODIFIER_ARM_SPLIT_BLOCK_BIT: u64 = 32;

pub const FORMAT_MODIFIER_ARM_TE_BIT: u64 = 4096;

pub const FORMAT_MODIFIER_ARM_TILED_HEADER_BIT: u64 = 8192;

pub const FORMAT_MODIFIER_ARM_YUV_BIT: u64 = 16;

pub const FORMAT_MODIFIER_GOOGLE_GOLDFISH_OPTIMAL: u64 = 648518346341351425;

pub const FORMAT_MODIFIER_INTEL_CCS_BIT: u64 = 16777216;

pub const FORMAT_MODIFIER_INTEL_I915_X_TILED: u64 = 72057594037927937;

pub const FORMAT_MODIFIER_INTEL_I915_YF_TILED: u64 = 72057594037927939;

pub const FORMAT_MODIFIER_INTEL_I915_YF_TILED_CCS: u64 = 72057594054705155;

pub const FORMAT_MODIFIER_INTEL_I915_Y_TILED: u64 = 72057594037927938;

pub const FORMAT_MODIFIER_INTEL_I915_Y_TILED_CCS: u64 = 72057594054705154;

pub const FORMAT_MODIFIER_INVALID: u64 = FORMAT_MODIFIER_VALUE_RESERVED as u64;

pub const FORMAT_MODIFIER_LINEAR: u64 = 0;

pub const FORMAT_MODIFIER_NONE: u64 = 0;

pub const FORMAT_MODIFIER_VALUE_RESERVED: u64 = 72057594037927935;

pub const FORMAT_MODIFIER_VENDOR_AMD: u64 = 144115188075855872;

pub const FORMAT_MODIFIER_VENDOR_ARM: u64 = 576460752303423488;

pub const FORMAT_MODIFIER_VENDOR_BROADCOM: u64 = 504403158265495552;

/// This meaning of this value is deprecated. Use fuchsia.images2.FORMAT_MODIFIER_VENDOR_GOOGLE
/// instead which has a different value.
pub const FORMAT_MODIFIER_VENDOR_GOOGLE: u64 = 648518346341351424;

pub const FORMAT_MODIFIER_VENDOR_INTEL: u64 = 72057594037927936;

pub const FORMAT_MODIFIER_VENDOR_NONE: u64 = 0;

pub const FORMAT_MODIFIER_VENDOR_NVIDIA: u64 = 216172782113783808;

pub const FORMAT_MODIFIER_VENDOR_QCOM: u64 = 360287970189639680;

pub const FORMAT_MODIFIER_VENDOR_SAMSUNG: u64 = 288230376151711744;

pub const FORMAT_MODIFIER_VENDOR_VIVANTE: u64 = 432345564227567616;

pub const MAX_COUNT_BUFFER_COLLECTION_CONSTRAINTS_IMAGE_FORMAT_CONSTRAINTS: u32 = 32;

pub const MAX_COUNT_BUFFER_COLLECTION_INFO_BUFFERS: u32 = 64;

pub const MAX_COUNT_BUFFER_MEMORY_CONSTRAINTS_HEAP_PERMITTED: u32 = 32;

/// Actually creating this many children isn't recommended in most typical
/// scenarios, but isn't prevented, for testing reasons, and just in case an
/// unusual scenario needs it.  Mitigation of potentially high time complexity
/// in sysmem will limit the actual number of group child combinations
/// considered in aggregation attempts to a separate maximum that is not
/// settable via these protocols.  The maximum number of total nodes in a sysmem
/// token tree is limited to a separate maximum that is not settable via these
/// protocols.
pub const MAX_COUNT_CREATE_CHILDREN: i32 = 64;

pub const MAX_COUNT_DUPLICATES: u32 = 64;

pub const MAX_COUNT_IMAGE_FORMAT_CONSTRAINTS_COLOR_SPACES: u32 = 32;

pub const MAX_HEAPS_COUNT: u32 = 32;

pub const MAX_RANGES_COUNT: u32 = 128;

pub const VULKAN_BUFFER_USAGE_INDEX_BUFFER: u32 = 4194304;

pub const VULKAN_BUFFER_USAGE_INDIRECT_BUFFER: u32 = 16777216;

pub const VULKAN_BUFFER_USAGE_STORAGE_BUFFER: u32 = 2097152;

pub const VULKAN_BUFFER_USAGE_STORAGE_TEXEL_BUFFER: u32 = 524288;

pub const VULKAN_BUFFER_USAGE_TRANSFER_DST: u32 = 131072;

pub const VULKAN_BUFFER_USAGE_TRANSFER_SRC: u32 = 65536;

pub const VULKAN_BUFFER_USAGE_UNIFORM_BUFFER: u32 = 1048576;

pub const VULKAN_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER: u32 = 262144;

pub const VULKAN_BUFFER_USAGE_VERTEX_BUFFER: u32 = 8388608;

pub const VULKAN_IMAGE_USAGE_COLOR_ATTACHMENT: u32 = 16;

pub const VULKAN_IMAGE_USAGE_INPUT_ATTACHMENT: u32 = 128;

pub const VULKAN_IMAGE_USAGE_SAMPLED: u32 = 4;

pub const VULKAN_IMAGE_USAGE_STENCIL_ATTACHMENT: u32 = 32;

pub const VULKAN_IMAGE_USAGE_STORAGE: u32 = 8;

pub const VULKAN_IMAGE_USAGE_TRANSFER_DST: u32 = 2;

pub const VULKAN_IMAGE_USAGE_TRANSFER_SRC: u32 = 1;

pub const VULKAN_IMAGE_USAGE_TRANSIENT_ATTACHMENT: u32 = 64;

pub const CPU_USAGE_READ: u32 = 1;

pub const CPU_USAGE_READ_OFTEN: u32 = 2;

pub const CPU_USAGE_WRITE: u32 = 4;

pub const CPU_USAGE_WRITE_OFTEN: u32 = 8;

pub const DISPLAY_USAGE_CURSOR: u32 = 2;

pub const DISPLAY_USAGE_LAYER: u32 = 1;

pub const NONE_USAGE: u32 = 1;

pub const VIDEO_USAGE_CAPTURE: u32 = 8;

pub const VIDEO_USAGE_DECRYPTOR_OUTPUT: u32 = 16;

pub const VIDEO_USAGE_HW_DECODER: u32 = 1;

pub const VIDEO_USAGE_HW_DECODER_INTERNAL: u32 = 32;

pub const VIDEO_USAGE_HW_ENCODER: u32 = 2;

pub const VIDEO_USAGE_HW_PROTECTED: u32 = 4;

pub const VULKAN_USAGE_COLOR_ATTACHMENT: u32 = 16;

pub const VULKAN_USAGE_INPUT_ATTACHMENT: u32 = 128;

pub const VULKAN_USAGE_SAMPLED: u32 = 4;

pub const VULKAN_USAGE_STENCIL_ATTACHMENT: u32 = 32;

pub const VULKAN_USAGE_STORAGE: u32 = 8;

pub const VULKAN_USAGE_TRANSFER_DST: u32 = 2;

pub const VULKAN_USAGE_TRANSFER_SRC: u32 = 1;

pub const VULKAN_USAGE_TRANSIENT_ATTACHMENT: u32 = 64;

/// Inaccessible is only for cases where there is no CPU-based access to the
/// buffers.  A secure_required buffer can still have CoherencyDomain Cpu or
/// Ram even if the secure_required buffer can only be accessed by the CPU when
/// the CPU is running in secure mode (or similar).  In contrast, device-local
/// memory that isn't reachable from the CPU is CoherencyDomain Inaccessible,
/// even if it's possible to cause a device (physical or virtual) to copy the
/// data from the Inaccessible buffers to buffers that are visible to the CPU.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum CoherencyDomain {
    Cpu = 0,
    Ram = 1,
    Inaccessible = 2,
}

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

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

/// This list has a separate entry for each variant of a color space standard.
///
/// For this reason, should we ever add support for the RGB variant of 709, for
/// example, we'd add a separate entry to this list for that variant.  Similarly
/// for the RGB variants of 2020 or 2100.  Similarly for the YcCbcCrc variant of
/// 2020.  Similarly for the ICtCp variant of 2100.
///
/// A given ColorSpaceType may permit usage with a PixelFormatType(s) that
/// provides a bits-per-sample that's compatible with the ColorSpaceType's
/// official spec.  Not all spec-valid combinations are necessarily supported.
/// See ImageFormatIsSupportedColorSpaceForPixelFormat() for the best-case degree
/// of support, but a "true" from that function doesn't guarantee that any given
/// combination of participants will all support the desired combination of
/// ColorSpaceType and PixelFormatType.
///
/// The sysmem service helps find a mutually supported combination and allocate
/// suitable buffers.
///
/// A ColorSpaceType's spec is not implicitly extended to support
/// outside-the-standard bits-per-sample (R, G, B, or Y sample).  For example,
/// for 2020 and 2100, 8 bits-per-Y-sample is not supported (by sysmem), because
/// 8 bits-per-Y-sample is not in the spec for 2020 or 2100.  A sysmem
/// participant that attempts to advertise support for a PixelFormat + ColorSpace
/// that's non-standard will cause sysmem to reject the combo and fail to
/// allocate (intentionally, to strongly discourage specifying
/// insufficiently-defined combos).
///
/// This type is deprecated for new code, but is still used by some camera code.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ColorSpaceType {
    /// Not a valid color space type.
    Invalid = 0,
    /// sRGB
    Srgb = 1,
    /// 601 NTSC ("525 line") YCbCr primaries, narrow
    Rec601Ntsc = 2,
    /// 601 NTSC ("525 line") YCbCr primaries, wide
    Rec601NtscFullRange = 3,
    /// 601 PAL ("625 line") YCbCr primaries, narrow
    Rec601Pal = 4,
    /// 601 PAL ("625 line") YCbCr primaries, wide
    Rec601PalFullRange = 5,
    /// 709 YCbCr (not RGB)
    Rec709 = 6,
    /// 2020 YCbCr (not RGB, not YcCbcCrc)
    Rec2020 = 7,
    /// 2100 YCbCr (not RGB, not ICtCp)
    Rec2100 = 8,
    /// Either the pixel format doesn't represent a color, or it's in an
    /// application-specific colorspace that isn't describable by another entry
    /// in this enum.
    PassThrough = 9,
    /// The sysmem client is explicitly indicating that the sysmem client does
    /// not care which color space is chosen / used.
    DoNotCare = 4294967294,
}

impl ColorSpaceType {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Invalid),
            1 => Some(Self::Srgb),
            2 => Some(Self::Rec601Ntsc),
            3 => Some(Self::Rec601NtscFullRange),
            4 => Some(Self::Rec601Pal),
            5 => Some(Self::Rec601PalFullRange),
            6 => Some(Self::Rec709),
            7 => Some(Self::Rec2020),
            8 => Some(Self::Rec2100),
            9 => Some(Self::PassThrough),
            4294967294 => Some(Self::DoNotCare),
            _ => None,
        }
    }

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

/// Known heap types.
/// Device specific types should have bit 60 set. Top order bit is reserved
/// and should not be set.
///
/// This type is deprecated for new code, but is still used by some camera code.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u64)]
pub enum HeapType {
    SystemRam = 0,
    /// Heap used for amlogic protected memory.
    AmlogicSecure = 1152921504606912512,
    /// Heap used for amlogic protected memory between decrypt and video decode.
    AmlogicSecureVdec = 1152921504606912513,
    /// Heap used by goldfish vulkan for device-local memory.
    GoldfishDeviceLocal = 1152921504606978048,
    /// Heap used by goldfish vulkan for host-visible memory.
    GoldfishHostVisible = 1152921504606978049,
    /// Heap used for display framebuffer. This is used by display drivers
    /// limited to a single framebuffer located at a specific physical address.
    /// The framebuffer heap makes it possible to create buffer collections
    /// for the framebuffer and enables sysmem support in these drivers.
    Framebuffer = 1152921504607043585,
}

impl HeapType {
    #[inline]
    pub fn from_primitive(prim: u64) -> Option<Self> {
        match prim {
            0 => Some(Self::SystemRam),
            1152921504606912512 => Some(Self::AmlogicSecure),
            1152921504606912513 => Some(Self::AmlogicSecureVdec),
            1152921504606978048 => Some(Self::GoldfishDeviceLocal),
            1152921504606978049 => Some(Self::GoldfishHostVisible),
            1152921504607043585 => Some(Self::Framebuffer),
            _ => None,
        }
    }

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

/// The ordering of the channels in the format name reflects how
/// the actual layout of the channel.
///
/// Each of these values is opinionated re. the color spaces that can be
/// contained within (in contrast with Vulkan).
///
/// This should be kept in sync with fuchsia.sysmem2.PixelFormatType.
///
/// This type is deprecated for new code, but is still used by some camera code.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum PixelFormatType {
    Invalid = 0,
    /// RGB only, 8 bits per each of R/G/B/A sample
    /// Compatible with VK_FORMAT_R8G8B8A8_UNORM.
    R8G8B8A8 = 1,
    /// 32bpp BGRA, 1 plane.  RGB only, 8 bits per each of B/G/R/A sample.
    /// Compatible with VK_FORMAT_B8G8R8A8_UNORM.
    Bgra32 = 101,
    /// YUV only, 8 bits per Y sample
    /// Compatible with VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM.
    I420 = 102,
    /// YUV only, 8 bits per Y sample
    /// Not compatible with any vulkan format.
    M420 = 103,
    /// YUV only, 8 bits per Y sample
    /// Compatible with VK_FORMAT_G8_B8R8_2PLANE_420_UNORM.
    Nv12 = 104,
    /// YUV only, 8 bits per Y sample
    /// Compatible with VK_FORMAT_G8B8G8R8_422_UNORM.
    Yuy2 = 105,
    Mjpeg = 106,
    /// YUV only, 8 bits per Y sample
    /// Compatible with VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM. The U plane may be located in either
    /// the B or R plane for the image (and likewise for the V plane); the ordering may be
    /// determined by looking at the members of
    /// `VkBufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents`.
    Yv12 = 107,
    /// 24bpp BGR, 1 plane. RGB only, 8 bits per each of B/G/R sample
    /// Compatible with VK_FORMAT_B8G8R8_UNORM.
    Bgr24 = 108,
    /// 16bpp RGB, 1 plane. 5 bits R, 6 bits G, 5 bits B
    /// Compatible with VK_FORMAT_R5G6B5_UNORM_PACK16.
    Rgb565 = 109,
    /// 8bpp RGB, 1 plane. 3 bits R, 3 bits G, 2 bits B
    /// Not compatible with any vulkan format.
    Rgb332 = 110,
    /// 8bpp RGB, 1 plane. 2 bits R, 2 bits G, 2 bits B
    /// Not compatible with any vulkan format.
    Rgb2220 = 111,
    /// 8bpp, Luminance-only (red, green and blue have identical values.)
    /// Compatible with VK_FORMAT_R8_UNORM.
    L8 = 112,
    /// 8bpp, Red-only (Green and Blue are to be interpreted as 0).
    /// Compatible with VK_FORMAT_R8_UNORM.
    R8 = 113,
    /// 16bpp RG, 1 plane. 8 bits R, 8 bits G.
    /// Compatible with VK_FORMAT_R8G8_UNORM.
    R8G8 = 114,
    /// 32bpp RGBA, 1 plane. 2 bits A, 10 bits R/G/B.
    /// Compatible with VK_FORMAT_A2R10G10B10_UNORM_PACK32.
    A2R10G10B10 = 115,
    /// 32bpp BGRA, 1 plane. 2 bits A, 10 bits R/G/B.
    /// Compatible with VK_FORMAT_A2B10G10R10_UNORM_PACK32.
    A2B10G10R10 = 116,
    /// The sysmem client is explicitly indicating that the sysmem client does
    /// not care which pixel format is chosen / used.  When setting this value,
    /// the sysmem client must not set format_modifier_value.
    DoNotCare = 4294967294,
}

impl PixelFormatType {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Invalid),
            1 => Some(Self::R8G8B8A8),
            101 => Some(Self::Bgra32),
            102 => Some(Self::I420),
            103 => Some(Self::M420),
            104 => Some(Self::Nv12),
            105 => Some(Self::Yuy2),
            106 => Some(Self::Mjpeg),
            107 => Some(Self::Yv12),
            108 => Some(Self::Bgr24),
            109 => Some(Self::Rgb565),
            110 => Some(Self::Rgb332),
            111 => Some(Self::Rgb2220),
            112 => Some(Self::L8),
            113 => Some(Self::R8),
            114 => Some(Self::R8G8),
            115 => Some(Self::A2R10G10B10),
            116 => Some(Self::A2B10G10R10),
            4294967294 => Some(Self::DoNotCare),
            _ => None,
        }
    }

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

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

impl fidl::Persistable for AllocatorSetDebugClientInfoRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct AllocatorValidateBufferCollectionTokenRequest {
    pub token_server_koid: u64,
}

impl fidl::Persistable for AllocatorValidateBufferCollectionTokenRequest {}

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

impl fidl::Persistable for AllocatorValidateBufferCollectionTokenResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct BufferCollectionCheckBuffersAllocatedResponse {
    pub status: i32,
}

impl fidl::Persistable for BufferCollectionCheckBuffersAllocatedResponse {}

/// Constraints on BufferCollection parameters.  These constraints can be
/// specified per-participant.  The sysmem service implements aggregation of
/// constraints from multiple participants.
///
/// This type is deprecated for new code, but is still used by some camera code.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferCollectionConstraints {
    /// The usage is only meant as a hint to help sysmem choose a more optimal
    /// PixelFormat or similar when multiple compatible options exist.
    ///
    /// When aggregating BufferCollectionConstraints, these values bitwise-OR.
    ///
    /// At least one usage bit must be specified unless the whole
    /// BufferCollectionConstraints is logically null due to !has_constraints.
    pub usage: BufferUsage,
    /// Per-participant number of buffers that the participant may concurrently
    /// hold for its exclusive use for a non-transient period of time (camp on).
    ///
    /// For example, a video decoder would specify (at least) the maximum number
    /// of reference frames + 1 frame currently being decoded into.
    ///
    /// A participant must not camp on more buffers than specified here (except
    /// very transiently) else processing may get stuck.
    ///
    /// When aggregating BufferCollectionConstraints, these values add.
    ///
    /// In testing scenarios, camping on more buffers than this for any
    /// significant duration may (ideally will) be flagged as a failure.  In
    /// testing scenarios, the participant may not be provided with more buffers
    /// than this concurrently.
    pub min_buffer_count_for_camping: u32,
    /// Per-participant minimum number of buffers that are needed for slack
    /// reasons, for better overlap of processing / better performance.
    ///
    /// When aggregating BufferCollectionConstraints, these values add.
    ///
    /// A participant should typically specify 0 or 1 here - typically 0 is
    /// appropriate if min_buffer_count_for_camping is already enough to keep
    /// the participant busy 100% of the time when the participant is slightly
    /// behind, while 1 can be appropriate if 1 more buffer than strictly needed
    /// for min-camping reasons gives enough slack to stay busy 100% of the time
    /// (when slightly behind, vs. lower % without the extra buffer).
    ///
    /// In testing scenarios, this field may be forced to 0, and all
    /// participants are expected to continue to work without getting stuck.  If
    /// a buffer is needed for forward progress reasons, that buffer should be
    /// accounted for in min_buffer_count_for_camping.
    pub min_buffer_count_for_dedicated_slack: u32,
    /// Similar to min_buffer_count_for_dedicated_slack, except when aggregating
    /// these values max (instead of add).  The value here is not shared with
    /// any participant's min_buffer_count_for_dedicated_slack.
    ///
    /// A participant can specify > 0 here if a participant would like to ensure
    /// there's some slack overall, but doesn't need that slack to be dedicated.
    ///
    /// The choice whether to use min_buffer_count_for_dedicated_slack or
    /// min_buffer_count_for_shared_slack (or both) will typically be about the
    /// degree to which the extra slack improves performance.
    ///
    /// In testing scenarios, this field may be forced to 0, and all
    /// participants are expected to continue to work without getting stuck.  If
    /// a buffer is needed for forward progress reasons, that buffer should be
    /// accounted for in min_buffer_count_for_camping.
    pub min_buffer_count_for_shared_slack: u32,
    /// A particularly-picky participant may unfortunately need to demand a
    /// tight range of buffer_count, or even a specific buffer_count.  This
    /// field should remain 0 unless a participant really must set this field to
    /// constrain the overall BufferCollectionInfo_2.buffer_count.  Any such
    /// participant should still fill out the min_buffer_count_for_* fields
    /// above.
    pub min_buffer_count: u32,
    /// 0 is treated as 0xFFFFFFFF.
    pub max_buffer_count: u32,
    /// Constraints on BufferCollectionSettings.buffer_settings.
    ///
    /// A participant that intends to specify image_format_constraints_count > 1
    /// will typically specify the minimum buffer size implicitly via
    /// image_format_constraints, and possibly specify only the max buffer size
    /// via buffer_memory_constraints.
    pub has_buffer_memory_constraints: bool,
    pub buffer_memory_constraints: BufferMemoryConstraints,
    /// Optional constraints on the image format parameters of an image stored
    /// in a buffer of the BufferCollection.  This includes pixel format and
    /// image layout.  These constraints are per-pixel-format, so more than one
    /// is permitted. Entries in the list must have unique pixel_formats.
    ///
    /// When aggregating, only pixel formats that are specified by all
    /// participants with non-zero image_format_constraints_count (and non-Null)
    /// BufferCollectionConstraints are retained.
    pub image_format_constraints_count: u32,
    pub image_format_constraints: [ImageFormatConstraints; 32],
}

impl fidl::Persistable for BufferCollectionConstraints {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferCollectionSetConstraintsRequest {
    pub has_constraints: bool,
    pub constraints: BufferCollectionConstraints,
}

impl fidl::Persistable for BufferCollectionSetConstraintsRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferCollectionTokenDuplicateSyncRequest {
    pub rights_attenuation_masks: Vec<fidl::Rights>,
}

impl fidl::Persistable for BufferCollectionTokenDuplicateSyncRequest {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferCollectionTokenGroupCreateChildrenSyncRequest {
    pub rights_attenuation_masks: Vec<fidl::Rights>,
}

impl fidl::Persistable for BufferCollectionTokenGroupCreateChildrenSyncRequest {}

/// Describes how the contents of buffers are represented.
/// Buffers of each type are described by their own tables.
///
/// This type is deprecated for new code, but is still used by some camera code.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferFormat {
    /// Since this struct used to be a single member union, we kept the tag
    /// to avoid any wire format changes. The tag must be set to `0`,
    /// no other value is correct.
    pub tag: u32,
    pub image: ImageFormat,
}

impl fidl::Persistable for BufferFormat {}

/// This type is deprecated for new code, but is still used by some camera code.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferMemoryConstraints {
    pub min_size_bytes: u32,
    /// 0 is treated as 0xFFFFFFFF.
    pub max_size_bytes: u32,
    pub physically_contiguous_required: bool,
    /// If true, at least one participant requires secure memory.
    ///
    /// When aggregating BufferCollectionConstraints, these values boolean-OR.
    pub secure_required: bool,
    /// By default, participants must ensure the CPU can read or write data to
    /// the buffer without cache operations. If they support using the RAM
    /// domain, data must be available in RAM (with CPU cache state such that
    /// the RAM data won't get corrupted by a dirty CPU cache line writing
    /// incorrect data to RAM), and a consumer reading using the CPU must
    /// invalidate CPU cache before reading (the producer doesn't guarantee
    /// zero stale "clean" cache lines)
    pub ram_domain_supported: bool,
    pub cpu_domain_supported: bool,
    pub inaccessible_domain_supported: bool,
    /// Optional heap constraints. Participants that don't care which heap
    /// memory is allocated on should leave this field 0.
    pub heap_permitted_count: u32,
    pub heap_permitted: [HeapType; 32],
}

impl fidl::Persistable for BufferMemoryConstraints {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BufferMemorySettings {
    pub size_bytes: u32,
    pub is_physically_contiguous: bool,
    pub is_secure: bool,
    pub coherency_domain: CoherencyDomain,
    /// The specific heap from which buffers are allocated.
    /// See above in this file for heap identifier values.
    pub heap: HeapType,
}

impl fidl::Persistable for BufferMemorySettings {}

/// Describes how a client will access the contents of a buffer.
///
/// This type is deprecated for new code, but is still used by some camera code.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct BufferUsage {
    pub none: u32,
    pub cpu: u32,
    pub vulkan: u32,
    pub display: u32,
    pub video: u32,
}

impl fidl::Persistable for BufferUsage {}

/// Describes how the pixels within an image are meant to be presented.
/// Simple color spaces need only a type.
/// Parametric color spaces may require additional properties.
///
/// This type is deprecated for new code, but is still used by some camera code.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ColorSpace {
    pub type_: ColorSpaceType,
}

impl fidl::Persistable for ColorSpace {}

/// This type is deprecated for new code, but is still used by some camera code.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FormatModifier {
    /// The upper 8 bits are a vendor code as allocated in FormatModifierVendor
    /// enum.  The lower 56 bits are vendor-defined.
    ///
    /// This field and the values that go in this field are defined this way for
    /// compatibility reasons.
    pub value: u64,
}

impl fidl::Persistable for FormatModifier {}

/// Describes how an image is represented.
///
/// This type is deprecated for new code, but still used by some camera code.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ImageFormat {
    /// Row width in pixels.
    pub width: u32,
    /// Number of rows.
    pub height: u32,
    /// Number of layers within a multi-layered image.
    /// Defaults to 1 if not specified.
    pub layers: u32,
    /// Pixel format.
    pub pixel_format: PixelFormat,
    /// Color space.
    pub color_space: ColorSpace,
    pub planes: [ImagePlane; 4],
}

impl fidl::Persistable for ImageFormat {}

/// Describes constraints on layout of image data in buffers.
///
/// This type is deprecated for new code, but is still used by some camera code.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ImageFormatConstraints {
    /// The PixelFormat for which the following constraints apply.  A
    /// participant may have more than one PixelFormat that's supported, in
    /// which case that participant can use a list of ImageFormatConstraints
    /// with an entry per PixelFormat.  It's not uncommon for the other fields
    /// of ImageFormatConstraints to vary by PixelFormat - for example for a
    /// linear format to support smaller max size than a tiled format.
    pub pixel_format: PixelFormat,
    /// Empty is an error.  Redundant entries are an error.  Arbitrary ordering
    /// is not an error.
    pub color_spaces_count: u32,
    pub color_space: [ColorSpace; 32],
    /// Minimum permitted width in pixels.
    ///
    /// For example a video decoder participant may set this field to the
    /// minimum coded_width that might potentially be specified by a stream.  In
    /// contrast, required_min_coded_width would be set to the current
    /// coded_width specified by the stream.  While min_coded_width aggregates
    /// by taking the max, required_min_coded_width aggregates by taking the
    /// min.
    ///
    /// See also required_min_coded_width.
    pub min_coded_width: u32,
    /// Maximum width in pixels.  For example Scenic may set this field
    /// (directly or via sub-participants) to the maximum width that can be
    /// composited.
    /// 0 is treated as 0xFFFFFFFF.
    pub max_coded_width: u32,
    /// Minimum height in pixels.  For example a video decoder participant may
    /// set this field to the coded_height specified by a stream.
    pub min_coded_height: u32,
    /// Maximum height in pixels.  For example Scenic may set this field
    /// (directly or via sub-participants) to the maximum height that can be
    /// composited.
    /// 0 is treated as 0xFFFFFFFF.
    pub max_coded_height: u32,
    /// Must be >= the value implied by min_coded_width for plane 0.
    pub min_bytes_per_row: u32,
    /// Must be >= the value implied by max_coded_width for plane 0.
    /// 0 is treated as 0xFFFFFFFF.
    pub max_bytes_per_row: u32,
    /// The max image area in pixels is limited indirectly via
    /// BufferSettings.size_bytes, and can also be enforced directly via this
    /// field.
    /// 0 is treated as 0xFFFFFFFF.
    pub max_coded_width_times_coded_height: u32,
    /// Number of layers within a multi-layered image.
    /// 0 is treated as 1.
    pub layers: u32,
    /// coded_width % width_divisor must be 0.
    /// 0 is treated as 1.
    pub coded_width_divisor: u32,
    /// coded_height % height_divisor must be 0.
    /// 0 is treated as 1.
    pub coded_height_divisor: u32,
    /// bytes_per_row % bytes_per_row_divisor must be 0.
    /// 0 is treated as 1.
    pub bytes_per_row_divisor: u32,
    /// vmo_usable_start % start_offset_divisor must be 0.
    /// 0 is treated as 1.
    pub start_offset_divisor: u32,
    /// display_width % display_width_divisor must be 0.
    /// 0 is treated as 1.
    pub display_width_divisor: u32,
    /// display_height % display_height_divisor must be 0.
    /// 0 is treated as 1.
    pub display_height_divisor: u32,
    /// required_ dimension bounds.
    ///
    /// In contrast to the corresponding fields without "required_" at the
    /// start, these fields (when set to non-zero values) express a requirement
    /// that the resulting aggregated non-required_ fields specify a space that
    /// fully contain the space expressed by each participant's required_
    /// fields.
    ///
    /// For example, a producer video decoder is perfectly happy for the
    /// consumer to be willing to accept anything, and the video decoder doesn't
    /// really want to constrain the potential space of dimensions that might be
    /// seen in a stream and may be acceptable to the consumer, but the video
    /// decoder needs to ensure that the resulting dimension ranges contain
    /// at least the current dimensions decoded from the stream.
    ///
    /// Similarly, an initiator with a particular dynamic-dimension scenario in
    /// mind may wish to require up front that participants agree to handle at
    /// least the range of dimensions expected by the initiator in that
    /// scenario (else fail earlier rather than later, maybe trying again with
    /// smaller required_ space).
    ///
    /// It's much more common for a producer or initiator to set these fields
    /// than for a consumer to set these fields.
    ///
    /// While the non-required_ fields aggregate by taking the intersection, the
    /// required_ fields aggregate by taking the union.
    ///
    /// If set, the required_max_coded_width and required_max_coded_height will
    /// cause the allocated buffers to be large enough to hold an image that is
    /// required_max_coded_width * required_max_coded_height.
    ///
    /// TODO(dustingreen): Make it easier to allocate buffers of minimal size
    /// that can (optionally) also handle 90 degree rotated version of the max
    /// dimensions / alternate required bounds for another main aspect ratio.
    /// 0 is treated as 0xFFFFFFFF.
    pub required_min_coded_width: u32,
    pub required_max_coded_width: u32,
    /// 0 is treated as 0xFFFFFFFF.
    pub required_min_coded_height: u32,
    pub required_max_coded_height: u32,
    /// 0 is treated as 0xFFFFFFFF.
    pub required_min_bytes_per_row: u32,
    pub required_max_bytes_per_row: u32,
}

impl fidl::Persistable for ImageFormatConstraints {}

/// Describes how an image is represented.
///
/// This type is deprecated for new code, but is still used by some camera code
/// and by StreamProcessor (for now).
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ImageFormat2 {
    /// Pixel format.
    pub pixel_format: PixelFormat,
    /// Row width in pixels that exist in the buffer.  Must be >= display_width.
    /// Can be < the width implied by stride_bytes.
    pub coded_width: u32,
    /// Number of rows.  Must be >= display_height.
    pub coded_height: u32,
    /// Stride in bytes of plane 0.  Planes beyond plane 0 (if any, depending on
    /// pixel_format) have a known fixed relationship with plane 0's stride.
    /// For Intel tiled textures, the stride is for the linearized version of the texture.
    pub bytes_per_row: u32,
    /// Row width in pixels that are to be displayed.  This can be <=
    /// coded_width.  Any cropping occurs on the right of the image (not left).
    pub display_width: u32,
    /// Number of rows to be displayed.  This can be <= coded_height, with any
    /// cropping on the bottom (not top).
    pub display_height: u32,
    /// Number of layers within a multi-layered image.
    pub layers: u32,
    /// Color space.
    pub color_space: ColorSpace,
    /// The pixel_aspect_ratio_width : pixel_aspect_ratio_height is the
    /// pixel aspect ratio (AKA sample aspect ratio aka SAR) for the luma
    /// (AKA Y) samples. A pixel_aspect_ratio of 1:1 mean square pixels. A
    /// pixel_aspect_ratio of 2:1 would mean pixels that are displayed twice
    /// as wide as they are tall. Codec implementation should ensure these
    /// two values are relatively prime by reducing the fraction (dividing
    /// both by GCF) if necessary.
    ///
    /// When has_pixel_aspect_ratio == false, the pixel_aspect_ratio is unknown.
    /// A default of 1:1 can be appropriate in some cases, but as always, a
    /// consumer may determine the actual pixel_aspect_ratio by OOB means.
    pub has_pixel_aspect_ratio: bool,
    pub pixel_aspect_ratio_width: u32,
    pub pixel_aspect_ratio_height: u32,
}

impl fidl::Persistable for ImageFormat2 {}

/// This type is deprecated without a direct replacement (intentionally), as
/// fuchsia.images2 doesn't require describing each plane separately.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ImagePlane {
    /// Byte offset of the start of the plane from the beginning of the image.
    pub byte_offset: u32,
    /// Stride in bytes per row.
    /// Only meaningful for linear buffer formats.
    pub bytes_per_row: u32,
}

impl fidl::Persistable for ImagePlane {}

/// Describes constraints for allocating images of some desired form.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ImageSpec {
    /// Minimum width in pixels.
    pub min_width: u32,
    /// Minimum height in pixels.
    pub min_height: u32,
    /// Number of layers within a multi-layered image.
    /// Defaults to 1 if not specified.
    pub layers: u32,
    /// Pixel format.
    pub pixel_format: PixelFormat,
    /// Color space.
    pub color_space: ColorSpace,
}

impl fidl::Persistable for ImageSpec {}

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

impl fidl::Persistable for NodeSetDebugClientInfoRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct NodeSetDebugTimeoutLogDeadlineRequest {
    pub deadline: i64,
}

impl fidl::Persistable for NodeSetDebugTimeoutLogDeadlineRequest {}

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

impl fidl::Persistable for NodeSetNameRequest {}

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

impl fidl::Persistable for NodeIsAlternateForResponse {}

/// Describes how the pixels within an image are represented.
/// Simple formats need only a type.
/// Parametric pixel formats may require additional properties.
///
/// This type is deprecated for new code, but is still used by some camera code.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PixelFormat {
    pub type_: PixelFormatType,
    /// This bool effectively makes format_modifier optional, to satisfy
    /// 'ForDeprecatedCBindings', to satisfy "FIDL Simple C Bindings".
    pub has_format_modifier: bool,
    pub format_modifier: FormatModifier,
}

impl fidl::Persistable for PixelFormat {}

#[derive(Clone, Debug, PartialEq)]
pub struct SecureMemAddSecureHeapPhysicalRangeRequest {
    pub heap_range: SecureHeapAndRange,
}

impl fidl::Persistable for SecureMemAddSecureHeapPhysicalRangeRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct SecureMemDeleteSecureHeapPhysicalRangeRequest {
    pub heap_range: SecureHeapAndRange,
}

impl fidl::Persistable for SecureMemDeleteSecureHeapPhysicalRangeRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct SecureMemGetPhysicalSecureHeapPropertiesRequest {
    pub entire_heap: SecureHeapAndRange,
}

impl fidl::Persistable for SecureMemGetPhysicalSecureHeapPropertiesRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct SecureMemModifySecureHeapPhysicalRangeRequest {
    pub range_modification: SecureHeapAndRangeModification,
}

impl fidl::Persistable for SecureMemModifySecureHeapPhysicalRangeRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct SecureMemZeroSubRangeRequest {
    pub is_covering_range_explicit: bool,
    pub heap_range: SecureHeapAndRange,
}

impl fidl::Persistable for SecureMemZeroSubRangeRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct SecureMemGetPhysicalSecureHeapPropertiesResponse {
    pub properties: SecureHeapProperties,
}

impl fidl::Persistable for SecureMemGetPhysicalSecureHeapPropertiesResponse {}

#[derive(Clone, Debug, PartialEq)]
pub struct SecureMemGetPhysicalSecureHeapsResponse {
    pub heaps: SecureHeapsAndRanges,
}

impl fidl::Persistable for SecureMemGetPhysicalSecureHeapsResponse {}

/// After the initial buffer allocation, it's allowed to close old buffers and
/// allocate new buffers.  When a new buffer is allocated its settings can
/// differ from the rest of the buffers in the collection, and the single
/// buffer's settings are delivered via OnSingleBufferAllocated() using this
/// struct:
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SingleBufferSettings {
    pub buffer_settings: BufferMemorySettings,
    /// Buffers holding data that is not uncompressed image data will not have
    /// this field set.  Buffers holding data that is uncompressed image data
    /// _may_ have this field set.
    ///
    /// At least for now, changing the PixelFormat requires re-allocating
    /// buffers.
    pub has_image_format_constraints: bool,
    pub image_format_constraints: ImageFormatConstraints,
}

impl fidl::Persistable for SingleBufferSettings {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct SecureHeapAndRange {
    pub heap: Option<HeapType>,
    pub range: Option<SecureHeapRange>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for SecureHeapAndRange {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct SecureHeapAndRangeModification {
    pub heap: Option<HeapType>,
    pub old_range: Option<SecureHeapRange>,
    pub new_range: Option<SecureHeapRange>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for SecureHeapAndRangeModification {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct SecureHeapAndRanges {
    /// This is which secure/protected heap.
    pub heap: Option<HeapType>,
    /// The list of physical ranges.  This list must be sorted by
    /// physical_address (lower first), and must not have any overlapping
    /// ranges.  Ranges that are directly adjacent are allowed (not
    /// overlapping).
    pub ranges: Option<Vec<SecureHeapRange>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for SecureHeapAndRanges {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct SecureHeapProperties {
    /// The HeapType is repeated here for convenience.
    pub heap: Option<HeapType>,
    /// If true, more than one call to SetPhysicalSecureHeap() for the same
    /// heap is allowed.  If false, only one SetPhyscialSecureHeap() call is
    /// allowed, and no calls to DeleteSecureHeapPhysicalRange() or
    /// ModifySecureHeapPhysicalRange() are allowed.  Even when this is false,
    /// the SecureMem server (driver) is still responsible for de-protecting
    /// just before warm reboot if protected ranges would not otherwise be
    /// cleaned up during a warm reboot.
    pub dynamic_protection_ranges: Option<bool>,
    /// The granularity of protection ranges.  If the granularity of start is
    /// different than granularity of end or length, then this is the max
    /// granularity value among those values.
    ///
    /// This must be a power of 2.  The client must not request ranges that
    /// specify smaller granularity.
    ///
    /// This must be at least zx_system_page_size() even if the HW can do
    /// smaller granularity.
    pub protected_range_granularity: Option<u32>,
    /// The SecureMem server should not count reserved ranges that the SecureMem
    /// server uses internally to get from range set A to range set B, if the
    /// SecureMem server needs to do any emulation of that sort.  Normally such
    /// emulation by the SecureMem server is unnecessary.  If any ranges are
    /// reserved by the SecureMem server, those reserved ranges are not
    /// available for use by the SecureMem client.
    ///
    /// If the number of ranges is limited only by available memory, it's ok for
    /// the SecureMem server to report 0xFFFFFFFFFFFFFFFF for this value.  The
    /// field must still be set.  As usual, the SecureMem server should ensure
    /// that SetPhysicalSecureHeapRanges() succeeds or fails atomically (either
    /// fully updates or rolls back before completing).
    pub max_protected_range_count: Option<u64>,
    /// Iff true, ModifySecureHeapPhysicalRange() is implemented.  Calling
    /// ModifySecureHeapPhysicalRange() when is_mod_protected_range_available
    /// is false is prohibited.  Don't attempt to detect availability of
    /// ModifySecureHeapPhysicalRange() by calling it to see if it fails; it
    /// may ZX_PANIC().
    pub is_mod_protected_range_available: Option<bool>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for SecureHeapProperties {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct SecureHeapRange {
    /// Must be aligned to at least heap_range_granularity.
    pub physical_address: Option<u64>,
    /// Must be aligned to at least heap_range_granularity.
    pub size_bytes: Option<u64>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for SecureHeapRange {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct SecureHeapsAndRanges {
    pub heaps: Option<Vec<SecureHeapAndRanges>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for SecureHeapsAndRanges {}

pub mod allocator_ordinals {
    pub const ALLOCATE_NON_SHARED_COLLECTION: u64 = 0x20f79299bbb4d2c6;
    pub const ALLOCATE_SHARED_COLLECTION: u64 = 0x7a757a57bfda0f71;
    pub const BIND_SHARED_COLLECTION: u64 = 0x146eca7ec46ff4ee;
    pub const VALIDATE_BUFFER_COLLECTION_TOKEN: u64 = 0x575b279b0236faea;
    pub const SET_DEBUG_CLIENT_INFO: u64 = 0x419f0d5b30728b26;
    pub const CONNECT_TO_SYSMEM2_ALLOCATOR: u64 = 0x13db3e3abac2e24;
}

pub mod buffer_collection_ordinals {
    pub const SYNC: u64 = 0x4577e238ae26291;
    pub const CLOSE: u64 = 0x5b1d7a4f5681fca7;
    pub const SET_NAME: u64 = 0x77a41bb6217e2443;
    pub const SET_DEBUG_CLIENT_INFO: u64 = 0x7275759070eb5ee2;
    pub const SET_DEBUG_TIMEOUT_LOG_DEADLINE: u64 = 0x46d38f4772638867;
    pub const SET_VERBOSE_LOGGING: u64 = 0x6bfbe2cf1701d288;
    pub const GET_NODE_REF: u64 = 0x467b7c75c35c3b84;
    pub const IS_ALTERNATE_FOR: u64 = 0x33a2a7aff2776c07;
    pub const SET_CONSTRAINTS: u64 = 0x4d9c3406c213227b;
    pub const WAIT_FOR_BUFFERS_ALLOCATED: u64 = 0x714667ea2a29a3a2;
    pub const CHECK_BUFFERS_ALLOCATED: u64 = 0x245bb81f79189e9;
    pub const ATTACH_TOKEN: u64 = 0x6f5adcca4ac7443e;
    pub const ATTACH_LIFETIME_TRACKING: u64 = 0x170d0f1d89d50989;
}

pub mod buffer_collection_token_ordinals {
    pub const SYNC: u64 = 0x4577e238ae26291;
    pub const CLOSE: u64 = 0x5b1d7a4f5681fca7;
    pub const SET_NAME: u64 = 0x77a41bb6217e2443;
    pub const SET_DEBUG_CLIENT_INFO: u64 = 0x7275759070eb5ee2;
    pub const SET_DEBUG_TIMEOUT_LOG_DEADLINE: u64 = 0x46d38f4772638867;
    pub const SET_VERBOSE_LOGGING: u64 = 0x6bfbe2cf1701d288;
    pub const GET_NODE_REF: u64 = 0x467b7c75c35c3b84;
    pub const IS_ALTERNATE_FOR: u64 = 0x33a2a7aff2776c07;
    pub const DUPLICATE_SYNC: u64 = 0x49ed7ab7cc19f18;
    pub const DUPLICATE: u64 = 0x2f9f81bdde4b7292;
    pub const SET_DISPENSABLE: u64 = 0x76e4ec34fc2cf5b3;
    pub const CREATE_BUFFER_COLLECTION_TOKEN_GROUP: u64 = 0x2f6243e05f22b9a7;
}

pub mod buffer_collection_token_group_ordinals {
    pub const SYNC: u64 = 0x4577e238ae26291;
    pub const CLOSE: u64 = 0x5b1d7a4f5681fca7;
    pub const SET_NAME: u64 = 0x77a41bb6217e2443;
    pub const SET_DEBUG_CLIENT_INFO: u64 = 0x7275759070eb5ee2;
    pub const SET_DEBUG_TIMEOUT_LOG_DEADLINE: u64 = 0x46d38f4772638867;
    pub const SET_VERBOSE_LOGGING: u64 = 0x6bfbe2cf1701d288;
    pub const GET_NODE_REF: u64 = 0x467b7c75c35c3b84;
    pub const IS_ALTERNATE_FOR: u64 = 0x33a2a7aff2776c07;
    pub const CREATE_CHILD: u64 = 0x2e74f8bcbf59ee59;
    pub const CREATE_CHILDREN_SYNC: u64 = 0x569dc3ca2a98f535;
    pub const ALL_CHILDREN_PRESENT: u64 = 0x1d41715f6f044b50;
}

pub mod node_ordinals {
    pub const SYNC: u64 = 0x4577e238ae26291;
    pub const CLOSE: u64 = 0x5b1d7a4f5681fca7;
    pub const SET_NAME: u64 = 0x77a41bb6217e2443;
    pub const SET_DEBUG_CLIENT_INFO: u64 = 0x7275759070eb5ee2;
    pub const SET_DEBUG_TIMEOUT_LOG_DEADLINE: u64 = 0x46d38f4772638867;
    pub const SET_VERBOSE_LOGGING: u64 = 0x6bfbe2cf1701d288;
    pub const GET_NODE_REF: u64 = 0x467b7c75c35c3b84;
    pub const IS_ALTERNATE_FOR: u64 = 0x33a2a7aff2776c07;
}

pub mod secure_mem_ordinals {
    pub const GET_PHYSICAL_SECURE_HEAPS: u64 = 0x782319d6ce7fa05;
    pub const GET_PHYSICAL_SECURE_HEAP_PROPERTIES: u64 = 0x26404e23f1271214;
    pub const ADD_SECURE_HEAP_PHYSICAL_RANGE: u64 = 0x1ca1abcee8a0b33e;
    pub const DELETE_SECURE_HEAP_PHYSICAL_RANGE: u64 = 0x728a953e56df92ee;
    pub const MODIFY_SECURE_HEAP_PHYSICAL_RANGE: u64 = 0x154fbfa3646a890d;
    pub const ZERO_SUB_RANGE: u64 = 0x7480f72bb5bc7e5b;
}

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

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

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

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

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

    impl fidl::encoding::ValueTypeMarker for CoherencyDomain {
        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 CoherencyDomain
    {
        #[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 CoherencyDomain {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Cpu
        }

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

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

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

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

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

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

    impl fidl::encoding::ValueTypeMarker for ColorSpaceType {
        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 ColorSpaceType {
        #[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 ColorSpaceType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Invalid
        }

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

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

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

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

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

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

    impl fidl::encoding::ValueTypeMarker for HeapType {
        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 HeapType {
        #[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 HeapType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::SystemRam
        }

        #[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::<u64>(offset);

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

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

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

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

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

    impl fidl::encoding::ValueTypeMarker for PixelFormatType {
        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 PixelFormatType
    {
        #[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 PixelFormatType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Invalid
        }

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

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

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

    unsafe impl fidl::encoding::TypeMarker for AllocatorSetDebugClientInfoRequest {
        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<AllocatorSetDebugClientInfoRequest, D>
        for &AllocatorSetDebugClientInfoRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AllocatorSetDebugClientInfoRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AllocatorSetDebugClientInfoRequest, D>::encode(
                (
                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.name,
                    ),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::BoundedString<64>, D>,
        T1: fidl::encoding::Encode<u64, D>,
    > fidl::encoding::Encode<AllocatorSetDebugClientInfoRequest, 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::<AllocatorSetDebugClientInfoRequest>(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 AllocatorSetDebugClientInfoRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(fidl::encoding::BoundedString<64>, D),
                id: 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);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::BoundedString<64>,
                D,
                &mut self.name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(u64, D, &mut self.id, decoder, offset + 16, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for AllocatorValidateBufferCollectionTokenRequest {
        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<AllocatorValidateBufferCollectionTokenRequest, D>
        for &AllocatorValidateBufferCollectionTokenRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AllocatorValidateBufferCollectionTokenRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut AllocatorValidateBufferCollectionTokenRequest).write_unaligned(
                    (self as *const AllocatorValidateBufferCollectionTokenRequest).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<AllocatorValidateBufferCollectionTokenRequest, 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::<AllocatorValidateBufferCollectionTokenRequest>(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 AllocatorValidateBufferCollectionTokenRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { token_server_koid: 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 AllocatorValidateBufferCollectionTokenResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for AllocatorValidateBufferCollectionTokenResponse {
        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<AllocatorValidateBufferCollectionTokenResponse, D>
        for &AllocatorValidateBufferCollectionTokenResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AllocatorValidateBufferCollectionTokenResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<AllocatorValidateBufferCollectionTokenResponse, D>::encode(
                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.is_known),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
        fidl::encoding::Encode<AllocatorValidateBufferCollectionTokenResponse, 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::<AllocatorValidateBufferCollectionTokenResponse>(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 AllocatorValidateBufferCollectionTokenResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { is_known: 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.is_known, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<BufferCollectionConstraints, D> for &BufferCollectionConstraints
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BufferCollectionConstraints>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BufferCollectionConstraints, D>::encode(
                (
                    <BufferUsage as fidl::encoding::ValueTypeMarker>::borrow(&self.usage),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.min_buffer_count_for_camping),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.min_buffer_count_for_dedicated_slack),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.min_buffer_count_for_shared_slack),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.min_buffer_count),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.max_buffer_count),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.has_buffer_memory_constraints),
                    <BufferMemoryConstraints as fidl::encoding::ValueTypeMarker>::borrow(&self.buffer_memory_constraints),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.image_format_constraints_count),
                    <fidl::encoding::Array<ImageFormatConstraints, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.image_format_constraints),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<BufferUsage, D>,
        T1: fidl::encoding::Encode<u32, D>,
        T2: fidl::encoding::Encode<u32, D>,
        T3: fidl::encoding::Encode<u32, D>,
        T4: fidl::encoding::Encode<u32, D>,
        T5: fidl::encoding::Encode<u32, D>,
        T6: fidl::encoding::Encode<bool, D>,
        T7: fidl::encoding::Encode<BufferMemoryConstraints, D>,
        T8: fidl::encoding::Encode<u32, D>,
        T9: fidl::encoding::Encode<fidl::encoding::Array<ImageFormatConstraints, 32>, D>,
    > fidl::encoding::Encode<BufferCollectionConstraints, D>
        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BufferCollectionConstraints>(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(40);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(328);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 20, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            self.3.encode(encoder, offset + 28, depth)?;
            self.4.encode(encoder, offset + 32, depth)?;
            self.5.encode(encoder, offset + 36, depth)?;
            self.6.encode(encoder, offset + 40, depth)?;
            self.7.encode(encoder, offset + 48, depth)?;
            self.8.encode(encoder, offset + 328, depth)?;
            self.9.encode(encoder, offset + 336, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for BufferCollectionConstraints
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                usage: fidl::new_empty!(BufferUsage, D),
                min_buffer_count_for_camping: fidl::new_empty!(u32, D),
                min_buffer_count_for_dedicated_slack: fidl::new_empty!(u32, D),
                min_buffer_count_for_shared_slack: fidl::new_empty!(u32, D),
                min_buffer_count: fidl::new_empty!(u32, D),
                max_buffer_count: fidl::new_empty!(u32, D),
                has_buffer_memory_constraints: fidl::new_empty!(bool, D),
                buffer_memory_constraints: fidl::new_empty!(BufferMemoryConstraints, D),
                image_format_constraints_count: fidl::new_empty!(u32, D),
                image_format_constraints: fidl::new_empty!(fidl::encoding::Array<ImageFormatConstraints, 32>, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
            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 + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(328) };
            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 + 328 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(BufferUsage, D, &mut self.usage, decoder, offset + 0, _depth)?;
            fidl::decode!(
                u32,
                D,
                &mut self.min_buffer_count_for_camping,
                decoder,
                offset + 20,
                _depth
            )?;
            fidl::decode!(
                u32,
                D,
                &mut self.min_buffer_count_for_dedicated_slack,
                decoder,
                offset + 24,
                _depth
            )?;
            fidl::decode!(
                u32,
                D,
                &mut self.min_buffer_count_for_shared_slack,
                decoder,
                offset + 28,
                _depth
            )?;
            fidl::decode!(u32, D, &mut self.min_buffer_count, decoder, offset + 32, _depth)?;
            fidl::decode!(u32, D, &mut self.max_buffer_count, decoder, offset + 36, _depth)?;
            fidl::decode!(
                bool,
                D,
                &mut self.has_buffer_memory_constraints,
                decoder,
                offset + 40,
                _depth
            )?;
            fidl::decode!(
                BufferMemoryConstraints,
                D,
                &mut self.buffer_memory_constraints,
                decoder,
                offset + 48,
                _depth
            )?;
            fidl::decode!(
                u32,
                D,
                &mut self.image_format_constraints_count,
                decoder,
                offset + 328,
                _depth
            )?;
            fidl::decode!(fidl::encoding::Array<ImageFormatConstraints, 32>, D, &mut self.image_format_constraints, decoder, offset + 336, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<BufferCollectionSetConstraintsRequest, D>
        for &BufferCollectionSetConstraintsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BufferCollectionSetConstraintsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BufferCollectionSetConstraintsRequest, D>::encode(
                (
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.has_constraints),
                    <BufferCollectionConstraints as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.constraints,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<bool, D>,
        T1: fidl::encoding::Encode<BufferCollectionConstraints, D>,
    > fidl::encoding::Encode<BufferCollectionSetConstraintsRequest, 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::<BufferCollectionSetConstraintsRequest>(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 BufferCollectionSetConstraintsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                has_constraints: fidl::new_empty!(bool, D),
                constraints: fidl::new_empty!(BufferCollectionConstraints, 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 = 0xffffffffffffff00u64;
            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!(bool, D, &mut self.has_constraints, decoder, offset + 0, _depth)?;
            fidl::decode!(
                BufferCollectionConstraints,
                D,
                &mut self.constraints,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BufferFormat, D>
        for &BufferFormat
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BufferFormat>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BufferFormat, D>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.tag),
                    <ImageFormat as fidl::encoding::ValueTypeMarker>::borrow(&self.image),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<u32, D>,
        T1: fidl::encoding::Encode<ImageFormat, D>,
    > fidl::encoding::Encode<BufferFormat, 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::<BufferFormat>(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 BufferFormat {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { tag: fidl::new_empty!(u32, D), image: fidl::new_empty!(ImageFormat, 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!(u32, D, &mut self.tag, decoder, offset + 0, _depth)?;
            fidl::decode!(ImageFormat, D, &mut self.image, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<BufferMemoryConstraints, D> for &BufferMemoryConstraints
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BufferMemoryConstraints>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BufferMemoryConstraints, D>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.min_size_bytes),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.max_size_bytes),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.physically_contiguous_required),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.secure_required),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.ram_domain_supported),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.cpu_domain_supported),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.inaccessible_domain_supported),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.heap_permitted_count),
                    <fidl::encoding::Array<HeapType, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.heap_permitted),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<u32, D>,
        T1: fidl::encoding::Encode<u32, D>,
        T2: fidl::encoding::Encode<bool, D>,
        T3: fidl::encoding::Encode<bool, D>,
        T4: fidl::encoding::Encode<bool, D>,
        T5: fidl::encoding::Encode<bool, D>,
        T6: fidl::encoding::Encode<bool, D>,
        T7: fidl::encoding::Encode<u32, D>,
        T8: fidl::encoding::Encode<fidl::encoding::Array<HeapType, 32>, D>,
    > fidl::encoding::Encode<BufferMemoryConstraints, 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::<BufferMemoryConstraints>(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(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 9, depth)?;
            self.4.encode(encoder, offset + 10, depth)?;
            self.5.encode(encoder, offset + 11, depth)?;
            self.6.encode(encoder, offset + 12, depth)?;
            self.7.encode(encoder, offset + 16, depth)?;
            self.8.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for BufferMemoryConstraints
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                min_size_bytes: fidl::new_empty!(u32, D),
                max_size_bytes: fidl::new_empty!(u32, D),
                physically_contiguous_required: fidl::new_empty!(bool, D),
                secure_required: fidl::new_empty!(bool, D),
                ram_domain_supported: fidl::new_empty!(bool, D),
                cpu_domain_supported: fidl::new_empty!(bool, D),
                inaccessible_domain_supported: fidl::new_empty!(bool, D),
                heap_permitted_count: fidl::new_empty!(u32, D),
                heap_permitted: fidl::new_empty!(fidl::encoding::Array<HeapType, 32>, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffff0000000000u64;
            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(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!(u32, D, &mut self.min_size_bytes, decoder, offset + 0, _depth)?;
            fidl::decode!(u32, D, &mut self.max_size_bytes, decoder, offset + 4, _depth)?;
            fidl::decode!(
                bool,
                D,
                &mut self.physically_contiguous_required,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(bool, D, &mut self.secure_required, decoder, offset + 9, _depth)?;
            fidl::decode!(bool, D, &mut self.ram_domain_supported, decoder, offset + 10, _depth)?;
            fidl::decode!(bool, D, &mut self.cpu_domain_supported, decoder, offset + 11, _depth)?;
            fidl::decode!(
                bool,
                D,
                &mut self.inaccessible_domain_supported,
                decoder,
                offset + 12,
                _depth
            )?;
            fidl::decode!(u32, D, &mut self.heap_permitted_count, decoder, offset + 16, _depth)?;
            fidl::decode!(fidl::encoding::Array<HeapType, 32>, D, &mut self.heap_permitted, decoder, offset + 24, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for BufferMemorySettings {
        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<BufferMemorySettings, D>
        for &BufferMemorySettings
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BufferMemorySettings>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BufferMemorySettings, D>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.size_bytes),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.is_physically_contiguous,
                    ),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.is_secure),
                    <CoherencyDomain as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.coherency_domain,
                    ),
                    <HeapType as fidl::encoding::ValueTypeMarker>::borrow(&self.heap),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<u32, D>,
        T1: fidl::encoding::Encode<bool, D>,
        T2: fidl::encoding::Encode<bool, D>,
        T3: fidl::encoding::Encode<CoherencyDomain, D>,
        T4: fidl::encoding::Encode<HeapType, D>,
    > fidl::encoding::Encode<BufferMemorySettings, D> for (T0, T1, T2, T3, T4)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BufferMemorySettings>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 5, depth)?;
            self.3.encode(encoder, offset + 8, depth)?;
            self.4.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BufferMemorySettings {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                size_bytes: fidl::new_empty!(u32, D),
                is_physically_contiguous: fidl::new_empty!(bool, D),
                is_secure: fidl::new_empty!(bool, D),
                coherency_domain: fidl::new_empty!(CoherencyDomain, D),
                heap: fidl::new_empty!(HeapType, 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 = 0xffff000000000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(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!(u32, D, &mut self.size_bytes, decoder, offset + 0, _depth)?;
            fidl::decode!(
                bool,
                D,
                &mut self.is_physically_contiguous,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(bool, D, &mut self.is_secure, decoder, offset + 5, _depth)?;
            fidl::decode!(
                CoherencyDomain,
                D,
                &mut self.coherency_domain,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(HeapType, D, &mut self.heap, decoder, offset + 16, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BufferUsage {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                none: fidl::new_empty!(u32, D),
                cpu: fidl::new_empty!(u32, D),
                vulkan: fidl::new_empty!(u32, D),
                display: fidl::new_empty!(u32, D),
                video: fidl::new_empty!(u32, D),
            }
        }

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

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ColorSpace, D>
        for &ColorSpace
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ColorSpace>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ColorSpace, D>::encode(
                (<ColorSpaceType as fidl::encoding::ValueTypeMarker>::borrow(&self.type_),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ColorSpaceType, D>>
        fidl::encoding::Encode<ColorSpace, 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::<ColorSpace>(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 ColorSpace {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { type_: fidl::new_empty!(ColorSpaceType, 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!(ColorSpaceType, D, &mut self.type_, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for FormatModifier {
        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<FormatModifier, D>
        for &FormatModifier
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FormatModifier>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FormatModifier)
                    .write_unaligned((self as *const FormatModifier).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<FormatModifier, 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::<FormatModifier>(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 FormatModifier {
        #[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 ImageFormat {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ImageFormat {
        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<ImageFormat, D>
        for &ImageFormat
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageFormat>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ImageFormat, D>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.width),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.height),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.layers),
                    <PixelFormat as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_format),
                    <ColorSpace as fidl::encoding::ValueTypeMarker>::borrow(&self.color_space),
                    <fidl::encoding::Array<ImagePlane, 4> as fidl::encoding::ValueTypeMarker>::borrow(&self.planes),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<u32, D>,
        T1: fidl::encoding::Encode<u32, D>,
        T2: fidl::encoding::Encode<u32, D>,
        T3: fidl::encoding::Encode<PixelFormat, D>,
        T4: fidl::encoding::Encode<ColorSpace, D>,
        T5: fidl::encoding::Encode<fidl::encoding::Array<ImagePlane, 4>, D>,
    > fidl::encoding::Encode<ImageFormat, D> for (T0, T1, T2, T3, T4, T5)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageFormat>(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(64);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 16, depth)?;
            self.4.encode(encoder, offset + 32, depth)?;
            self.5.encode(encoder, offset + 36, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ImageFormat {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                width: fidl::new_empty!(u32, D),
                height: fidl::new_empty!(u32, D),
                layers: fidl::new_empty!(u32, D),
                pixel_format: fidl::new_empty!(PixelFormat, D),
                color_space: fidl::new_empty!(ColorSpace, D),
                planes: fidl::new_empty!(fidl::encoding::Array<ImagePlane, 4>, 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,
                });
            }
            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!(u32, D, &mut self.width, decoder, offset + 0, _depth)?;
            fidl::decode!(u32, D, &mut self.height, decoder, offset + 4, _depth)?;
            fidl::decode!(u32, D, &mut self.layers, decoder, offset + 8, _depth)?;
            fidl::decode!(PixelFormat, D, &mut self.pixel_format, decoder, offset + 16, _depth)?;
            fidl::decode!(ColorSpace, D, &mut self.color_space, decoder, offset + 32, _depth)?;
            fidl::decode!(fidl::encoding::Array<ImagePlane, 4>, D, &mut self.planes, decoder, offset + 36, _depth)?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ImageFormatConstraints, D> for &ImageFormatConstraints
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageFormatConstraints>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ImageFormatConstraints, D>::encode(
                (
                    <PixelFormat as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_format),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.color_spaces_count),
                    <fidl::encoding::Array<ColorSpace, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.color_space),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.min_coded_width),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.max_coded_width),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.min_coded_height),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.max_coded_height),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.min_bytes_per_row),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.max_bytes_per_row),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.max_coded_width_times_coded_height),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.layers),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.coded_width_divisor),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.coded_height_divisor),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.bytes_per_row_divisor),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.start_offset_divisor),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.display_width_divisor),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.display_height_divisor),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.required_min_coded_width),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.required_max_coded_width),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.required_min_coded_height),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.required_max_coded_height),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.required_min_bytes_per_row),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.required_max_bytes_per_row),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<PixelFormat, D>,
        T1: fidl::encoding::Encode<u32, D>,
        T2: fidl::encoding::Encode<fidl::encoding::Array<ColorSpace, 32>, D>,
        T3: fidl::encoding::Encode<u32, D>,
        T4: fidl::encoding::Encode<u32, D>,
        T5: fidl::encoding::Encode<u32, D>,
        T6: fidl::encoding::Encode<u32, D>,
        T7: fidl::encoding::Encode<u32, D>,
        T8: fidl::encoding::Encode<u32, D>,
        T9: fidl::encoding::Encode<u32, D>,
        T10: fidl::encoding::Encode<u32, D>,
        T11: fidl::encoding::Encode<u32, D>,
        T12: fidl::encoding::Encode<u32, D>,
        T13: fidl::encoding::Encode<u32, D>,
        T14: fidl::encoding::Encode<u32, D>,
        T15: fidl::encoding::Encode<u32, D>,
        T16: fidl::encoding::Encode<u32, D>,
        T17: fidl::encoding::Encode<u32, D>,
        T18: fidl::encoding::Encode<u32, D>,
        T19: fidl::encoding::Encode<u32, D>,
        T20: fidl::encoding::Encode<u32, D>,
        T21: fidl::encoding::Encode<u32, D>,
        T22: fidl::encoding::Encode<u32, D>,
    > fidl::encoding::Encode<ImageFormatConstraints, D>
        for (
            T0,
            T1,
            T2,
            T3,
            T4,
            T5,
            T6,
            T7,
            T8,
            T9,
            T10,
            T11,
            T12,
            T13,
            T14,
            T15,
            T16,
            T17,
            T18,
            T19,
            T20,
            T21,
            T22,
        )
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageFormatConstraints>(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(224);
                (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 + 20, depth)?;
            self.3.encode(encoder, offset + 148, depth)?;
            self.4.encode(encoder, offset + 152, depth)?;
            self.5.encode(encoder, offset + 156, depth)?;
            self.6.encode(encoder, offset + 160, depth)?;
            self.7.encode(encoder, offset + 164, depth)?;
            self.8.encode(encoder, offset + 168, depth)?;
            self.9.encode(encoder, offset + 172, depth)?;
            self.10.encode(encoder, offset + 176, depth)?;
            self.11.encode(encoder, offset + 180, depth)?;
            self.12.encode(encoder, offset + 184, depth)?;
            self.13.encode(encoder, offset + 188, depth)?;
            self.14.encode(encoder, offset + 192, depth)?;
            self.15.encode(encoder, offset + 196, depth)?;
            self.16.encode(encoder, offset + 200, depth)?;
            self.17.encode(encoder, offset + 204, depth)?;
            self.18.encode(encoder, offset + 208, depth)?;
            self.19.encode(encoder, offset + 212, depth)?;
            self.20.encode(encoder, offset + 216, depth)?;
            self.21.encode(encoder, offset + 220, depth)?;
            self.22.encode(encoder, offset + 224, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ImageFormatConstraints
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                pixel_format: fidl::new_empty!(PixelFormat, D),
                color_spaces_count: fidl::new_empty!(u32, D),
                color_space: fidl::new_empty!(fidl::encoding::Array<ColorSpace, 32>, D),
                min_coded_width: fidl::new_empty!(u32, D),
                max_coded_width: fidl::new_empty!(u32, D),
                min_coded_height: fidl::new_empty!(u32, D),
                max_coded_height: fidl::new_empty!(u32, D),
                min_bytes_per_row: fidl::new_empty!(u32, D),
                max_bytes_per_row: fidl::new_empty!(u32, D),
                max_coded_width_times_coded_height: fidl::new_empty!(u32, D),
                layers: fidl::new_empty!(u32, D),
                coded_width_divisor: fidl::new_empty!(u32, D),
                coded_height_divisor: fidl::new_empty!(u32, D),
                bytes_per_row_divisor: fidl::new_empty!(u32, D),
                start_offset_divisor: fidl::new_empty!(u32, D),
                display_width_divisor: fidl::new_empty!(u32, D),
                display_height_divisor: fidl::new_empty!(u32, D),
                required_min_coded_width: fidl::new_empty!(u32, D),
                required_max_coded_width: fidl::new_empty!(u32, D),
                required_min_coded_height: fidl::new_empty!(u32, D),
                required_max_coded_height: fidl::new_empty!(u32, D),
                required_min_bytes_per_row: fidl::new_empty!(u32, D),
                required_max_bytes_per_row: 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);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(224) };
            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 + 224 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(PixelFormat, D, &mut self.pixel_format, decoder, offset + 0, _depth)?;
            fidl::decode!(u32, D, &mut self.color_spaces_count, decoder, offset + 16, _depth)?;
            fidl::decode!(fidl::encoding::Array<ColorSpace, 32>, D, &mut self.color_space, decoder, offset + 20, _depth)?;
            fidl::decode!(u32, D, &mut self.min_coded_width, decoder, offset + 148, _depth)?;
            fidl::decode!(u32, D, &mut self.max_coded_width, decoder, offset + 152, _depth)?;
            fidl::decode!(u32, D, &mut self.min_coded_height, decoder, offset + 156, _depth)?;
            fidl::decode!(u32, D, &mut self.max_coded_height, decoder, offset + 160, _depth)?;
            fidl::decode!(u32, D, &mut self.min_bytes_per_row, decoder, offset + 164, _depth)?;
            fidl::decode!(u32, D, &mut self.max_bytes_per_row, decoder, offset + 168, _depth)?;
            fidl::decode!(
                u32,
                D,
                &mut self.max_coded_width_times_coded_height,
                decoder,
                offset + 172,
                _depth
            )?;
            fidl::decode!(u32, D, &mut self.layers, decoder, offset + 176, _depth)?;
            fidl::decode!(u32, D, &mut self.coded_width_divisor, decoder, offset + 180, _depth)?;
            fidl::decode!(u32, D, &mut self.coded_height_divisor, decoder, offset + 184, _depth)?;
            fidl::decode!(u32, D, &mut self.bytes_per_row_divisor, decoder, offset + 188, _depth)?;
            fidl::decode!(u32, D, &mut self.start_offset_divisor, decoder, offset + 192, _depth)?;
            fidl::decode!(u32, D, &mut self.display_width_divisor, decoder, offset + 196, _depth)?;
            fidl::decode!(u32, D, &mut self.display_height_divisor, decoder, offset + 200, _depth)?;
            fidl::decode!(
                u32,
                D,
                &mut self.required_min_coded_width,
                decoder,
                offset + 204,
                _depth
            )?;
            fidl::decode!(
                u32,
                D,
                &mut self.required_max_coded_width,
                decoder,
                offset + 208,
                _depth
            )?;
            fidl::decode!(
                u32,
                D,
                &mut self.required_min_coded_height,
                decoder,
                offset + 212,
                _depth
            )?;
            fidl::decode!(
                u32,
                D,
                &mut self.required_max_coded_height,
                decoder,
                offset + 216,
                _depth
            )?;
            fidl::decode!(
                u32,
                D,
                &mut self.required_min_bytes_per_row,
                decoder,
                offset + 220,
                _depth
            )?;
            fidl::decode!(
                u32,
                D,
                &mut self.required_max_bytes_per_row,
                decoder,
                offset + 224,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ImageFormat2, D>
        for &ImageFormat2
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageFormat2>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ImageFormat2, D>::encode(
                (
                    <PixelFormat as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_format),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.coded_width),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.coded_height),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.bytes_per_row),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.display_width),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.display_height),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.layers),
                    <ColorSpace as fidl::encoding::ValueTypeMarker>::borrow(&self.color_space),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.has_pixel_aspect_ratio),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.pixel_aspect_ratio_width,
                    ),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.pixel_aspect_ratio_height,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<PixelFormat, D>,
        T1: fidl::encoding::Encode<u32, D>,
        T2: fidl::encoding::Encode<u32, D>,
        T3: fidl::encoding::Encode<u32, D>,
        T4: fidl::encoding::Encode<u32, D>,
        T5: fidl::encoding::Encode<u32, D>,
        T6: fidl::encoding::Encode<u32, D>,
        T7: fidl::encoding::Encode<ColorSpace, D>,
        T8: fidl::encoding::Encode<bool, D>,
        T9: fidl::encoding::Encode<u32, D>,
        T10: fidl::encoding::Encode<u32, D>,
    > fidl::encoding::Encode<ImageFormat2, D> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageFormat2>(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(40);
                (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 + 20, depth)?;
            self.3.encode(encoder, offset + 24, depth)?;
            self.4.encode(encoder, offset + 28, depth)?;
            self.5.encode(encoder, offset + 32, depth)?;
            self.6.encode(encoder, offset + 36, depth)?;
            self.7.encode(encoder, offset + 40, depth)?;
            self.8.encode(encoder, offset + 44, depth)?;
            self.9.encode(encoder, offset + 48, depth)?;
            self.10.encode(encoder, offset + 52, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ImageFormat2 {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                pixel_format: fidl::new_empty!(PixelFormat, D),
                coded_width: fidl::new_empty!(u32, D),
                coded_height: fidl::new_empty!(u32, D),
                bytes_per_row: fidl::new_empty!(u32, D),
                display_width: fidl::new_empty!(u32, D),
                display_height: fidl::new_empty!(u32, D),
                layers: fidl::new_empty!(u32, D),
                color_space: fidl::new_empty!(ColorSpace, D),
                has_pixel_aspect_ratio: fidl::new_empty!(bool, D),
                pixel_aspect_ratio_width: fidl::new_empty!(u32, D),
                pixel_aspect_ratio_height: 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);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffff0000000000u64;
            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!(PixelFormat, D, &mut self.pixel_format, decoder, offset + 0, _depth)?;
            fidl::decode!(u32, D, &mut self.coded_width, decoder, offset + 16, _depth)?;
            fidl::decode!(u32, D, &mut self.coded_height, decoder, offset + 20, _depth)?;
            fidl::decode!(u32, D, &mut self.bytes_per_row, decoder, offset + 24, _depth)?;
            fidl::decode!(u32, D, &mut self.display_width, decoder, offset + 28, _depth)?;
            fidl::decode!(u32, D, &mut self.display_height, decoder, offset + 32, _depth)?;
            fidl::decode!(u32, D, &mut self.layers, decoder, offset + 36, _depth)?;
            fidl::decode!(ColorSpace, D, &mut self.color_space, decoder, offset + 40, _depth)?;
            fidl::decode!(bool, D, &mut self.has_pixel_aspect_ratio, decoder, offset + 44, _depth)?;
            fidl::decode!(
                u32,
                D,
                &mut self.pixel_aspect_ratio_width,
                decoder,
                offset + 48,
                _depth
            )?;
            fidl::decode!(
                u32,
                D,
                &mut self.pixel_aspect_ratio_height,
                decoder,
                offset + 52,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

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

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ImagePlane {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { byte_offset: fidl::new_empty!(u32, D), bytes_per_row: fidl::new_empty!(u32, D) }
        }

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

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

    unsafe impl fidl::encoding::TypeMarker for ImageSpec {
        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<ImageSpec, D>
        for &ImageSpec
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageSpec>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ImageSpec, D>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.min_width),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.min_height),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.layers),
                    <PixelFormat as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_format),
                    <ColorSpace as fidl::encoding::ValueTypeMarker>::borrow(&self.color_space),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<u32, D>,
        T1: fidl::encoding::Encode<u32, D>,
        T2: fidl::encoding::Encode<u32, D>,
        T3: fidl::encoding::Encode<PixelFormat, D>,
        T4: fidl::encoding::Encode<ColorSpace, D>,
    > fidl::encoding::Encode<ImageSpec, D> for (T0, T1, T2, T3, T4)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ImageSpec>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 16, depth)?;
            self.4.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ImageSpec {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                min_width: fidl::new_empty!(u32, D),
                min_height: fidl::new_empty!(u32, D),
                layers: fidl::new_empty!(u32, D),
                pixel_format: fidl::new_empty!(PixelFormat, D),
                color_space: fidl::new_empty!(ColorSpace, 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,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(u32, D, &mut self.min_width, decoder, offset + 0, _depth)?;
            fidl::decode!(u32, D, &mut self.min_height, decoder, offset + 4, _depth)?;
            fidl::decode!(u32, D, &mut self.layers, decoder, offset + 8, _depth)?;
            fidl::decode!(PixelFormat, D, &mut self.pixel_format, decoder, offset + 16, _depth)?;
            fidl::decode!(ColorSpace, D, &mut self.color_space, decoder, offset + 32, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for NodeSetDebugClientInfoRequest {
        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<NodeSetDebugClientInfoRequest, D>
        for &NodeSetDebugClientInfoRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeSetDebugClientInfoRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NodeSetDebugClientInfoRequest, D>::encode(
                (
                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.name,
                    ),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::BoundedString<64>, D>,
        T1: fidl::encoding::Encode<u64, D>,
    > fidl::encoding::Encode<NodeSetDebugClientInfoRequest, 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::<NodeSetDebugClientInfoRequest>(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 NodeSetDebugClientInfoRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                name: fidl::new_empty!(fidl::encoding::BoundedString<64>, D),
                id: 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);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::BoundedString<64>,
                D,
                &mut self.name,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(u64, D, &mut self.id, decoder, offset + 16, _depth)?;
            Ok(())
        }
    }

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

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

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

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

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

    unsafe impl fidl::encoding::TypeMarker for NodeIsAlternateForResponse {
        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<NodeIsAlternateForResponse, D> for &NodeIsAlternateForResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NodeIsAlternateForResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NodeIsAlternateForResponse, D>::encode(
                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.is_alternate),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
        fidl::encoding::Encode<NodeIsAlternateForResponse, 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::<NodeIsAlternateForResponse>(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 NodeIsAlternateForResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { is_alternate: 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.is_alternate, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

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

    unsafe impl fidl::encoding::TypeMarker for PixelFormat {
        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<PixelFormat, D>
        for &PixelFormat
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PixelFormat>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PixelFormat, D>::encode(
                (
                    <PixelFormatType as fidl::encoding::ValueTypeMarker>::borrow(&self.type_),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.has_format_modifier),
                    <FormatModifier as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.format_modifier,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<PixelFormatType, D>,
        T1: fidl::encoding::Encode<bool, D>,
        T2: fidl::encoding::Encode<FormatModifier, D>,
    > fidl::encoding::Encode<PixelFormat, 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::<PixelFormat>(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 + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PixelFormat {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                type_: fidl::new_empty!(PixelFormatType, D),
                has_format_modifier: fidl::new_empty!(bool, D),
                format_modifier: fidl::new_empty!(FormatModifier, 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 = 0xffffff0000000000u64;
            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!(PixelFormatType, D, &mut self.type_, decoder, offset + 0, _depth)?;
            fidl::decode!(bool, D, &mut self.has_format_modifier, decoder, offset + 4, _depth)?;
            fidl::decode!(
                FormatModifier,
                D,
                &mut self.format_modifier,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

    unsafe impl fidl::encoding::TypeMarker for SecureMemZeroSubRangeRequest {
        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<SecureMemZeroSubRangeRequest, D> for &SecureMemZeroSubRangeRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SecureMemZeroSubRangeRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SecureMemZeroSubRangeRequest, D>::encode(
                (
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.is_covering_range_explicit,
                    ),
                    <SecureHeapAndRange as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.heap_range,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<bool, D>,
        T1: fidl::encoding::Encode<SecureHeapAndRange, D>,
    > fidl::encoding::Encode<SecureMemZeroSubRangeRequest, 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::<SecureMemZeroSubRangeRequest>(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 SecureMemZeroSubRangeRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                is_covering_range_explicit: fidl::new_empty!(bool, D),
                heap_range: fidl::new_empty!(SecureHeapAndRange, 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 = 0xffffffffffffff00u64;
            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!(
                bool,
                D,
                &mut self.is_covering_range_explicit,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                SecureHeapAndRange,
                D,
                &mut self.heap_range,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SingleBufferSettings, D>
        for &SingleBufferSettings
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SingleBufferSettings>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SingleBufferSettings, D>::encode(
                (
                    <BufferMemorySettings as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.buffer_settings,
                    ),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.has_image_format_constraints,
                    ),
                    <ImageFormatConstraints as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.image_format_constraints,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<BufferMemorySettings, D>,
        T1: fidl::encoding::Encode<bool, D>,
        T2: fidl::encoding::Encode<ImageFormatConstraints, D>,
    > fidl::encoding::Encode<SingleBufferSettings, 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::<SingleBufferSettings>(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(24);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 24, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SingleBufferSettings {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                buffer_settings: fidl::new_empty!(BufferMemorySettings, D),
                has_image_format_constraints: fidl::new_empty!(bool, D),
                image_format_constraints: fidl::new_empty!(ImageFormatConstraints, 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(24) };
            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 + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                BufferMemorySettings,
                D,
                &mut self.buffer_settings,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                bool,
                D,
                &mut self.has_image_format_constraints,
                decoder,
                offset + 24,
                _depth
            )?;
            fidl::decode!(
                ImageFormatConstraints,
                D,
                &mut self.image_format_constraints,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <HeapType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(HeapType, D));
                fidl::decode!(HeapType, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <SecureHeapRange as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.range.get_or_insert_with(|| fidl::new_empty!(SecureHeapRange, D));
                fidl::decode!(SecureHeapRange, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl SecureHeapAndRangeModification {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.new_range {
                return 3;
            }
            if let Some(_) = self.old_range {
                return 2;
            }
            if let Some(_) = self.heap {
                return 1;
            }
            0
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <HeapType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(HeapType, D));
                fidl::decode!(HeapType, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <SecureHeapRange as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.old_range.get_or_insert_with(|| fidl::new_empty!(SecureHeapRange, D));
                fidl::decode!(SecureHeapRange, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <SecureHeapRange as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.new_range.get_or_insert_with(|| fidl::new_empty!(SecureHeapRange, D));
                fidl::decode!(SecureHeapRange, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <HeapType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(HeapType, D));
                fidl::decode!(HeapType, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Vector<SecureHeapRange, 128> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.ranges.get_or_insert_with(
                    || fidl::new_empty!(fidl::encoding::Vector<SecureHeapRange, 128>, D),
                );
                fidl::decode!(fidl::encoding::Vector<SecureHeapRange, 128>, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl SecureHeapProperties {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.is_mod_protected_range_available {
                return 5;
            }
            if let Some(_) = self.max_protected_range_count {
                return 4;
            }
            if let Some(_) = self.protected_range_granularity {
                return 3;
            }
            if let Some(_) = self.dynamic_protection_ranges {
                return 2;
            }
            if let Some(_) = self.heap {
                return 1;
            }
            0
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <HeapType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(HeapType, D));
                fidl::decode!(HeapType, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.dynamic_protection_ranges.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .protected_range_granularity
                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.max_protected_range_count.get_or_insert_with(|| fidl::new_empty!(u64, D));
                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .is_mod_protected_range_available
                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

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

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

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

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

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.physical_address.get_or_insert_with(|| fidl::new_empty!(u64, D));
                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.size_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

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

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

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

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

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

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

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

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

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

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Vector<SecureHeapAndRanges, 32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.heaps.get_or_insert_with(
                    || fidl::new_empty!(fidl::encoding::Vector<SecureHeapAndRanges, 32>, D),
                );
                fidl::decode!(fidl::encoding::Vector<SecureHeapAndRanges, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }
}